Generating test data is a critical component of software testing, essential for ensuring the proper functioning of software systems. Automated test data generation, in particular, can greatly improve the efficiency and accuracy of the testing process. In 1990, the paper “Automated Software Test Data Generation,” published in IEEE Transactions on Software Engineering (Korel, 1990), introduced a novel approach to automated test data generation, focusing on actual program execution, fitness function minimization methods, and dynamic data flow analysis. This paper discusses the impact of the 1990 IEEE TSE publication (Korel, 1990) on automated test data generation and software engineering.

With the increased adoption of Model-Driven Engineering (MDE), where models are being used as the primary artifact of software, it is apparent that greater attention to the quality of the models is necessary. Traditionally, refactoring is used to enhance the quality of software systems at the source-code level; however, applying refactoring at the model level will have a more significant improvement on the system. After refactoring a model, proving that it still preserves its original behavior is crucial. In this paper, we present a process for applying refactoring transformations to the Extended Finite State Machine (EFSM) models using verified transformation rules that have been proven to preserve the model's original behavior. We provide a simplified three-step verification approach that can be used to prove that a transformation rule will generate a transformed model that is semantically equivalent to the original model. To do this, we formally define semantical equivalence at three different levels of granularity: models, sub-models, and transitions. Additionally, we introduce five model transformation rules and we demonstrate how our verification approach is used to prove the correctness of these rules. Finally, we present two case studies where we apply the proposed transformation process which adopts the five verified transformation rules. Using model testing, we show that applying a sequence of transformations using the verified transformation rules will keep both the original and the transformed model semantically equivalent. Additionally, the case studies show that model transformation can be used to enhance certain pre-defined model characteristics.

Many systems require high security during a limited operational timeframe. These systems can be exposed to many attacks that prevent tasks from being completed. To reduce the chances of a successful attack and increase the security of these systems, many fault tolerance architectures and defense strategies have been developed. N-version architecture is one technique to improve reliability and security. In this architecture, functionally equivalent variants of a program are developed and executed concurrently. However, due to the high cost of developing and maintaining N versions, it is used for large budget projects. In this paper, an alternative approach to improve security is K-variant architecture. By applying safe and automated program transformations, functionally equivalent variants of the original program are generated. The goal is to shift vulnerabilities in variants into different locations. These variants are executed simultaneously to complete a task so that the chance of a successful exploitation attack is decreased. In this paper, several types of memory exploitation attacks are analyzed along with the proposed four defense strategies. The experimental study investigates the effectiveness of defense strategies against these attacks. The results suggest that K-variant architecture with the proposed defense strategies may significantly improve the security of systems.

Software maintenance is becoming more challenging with the increased complexity of the software and the frequently applied changes. Performing impact analysis before the actual implementation of a change is a crucial task during system maintenance. While many tools and techniques are available to measure the impact of a change at the code level, only a few research work is done to measure the impact of a change at an earlier stage in the development process. Measuring the impact of a change at the model level speeds up the maintenance process allowing early discovery of critical components of the system before applying the actual change at the code level. In this paper, we present model-based impact analysis approach for state-based systems such as telecommunication or embedded systems. The proposed approach uses model dependencies to automatically measure the expected impact for a requested change instead of relying on the expertise of system maintainers, and it generates two impact sets representing the lower bound and the upper bound of the impact. Although it can be extended to other behavioral models, the presented approach mainly addresses extended finite-state machine (EFSM) models. An empirical study is conducted on six EFSM models to investigate the usefulness of the proposed approach. The results show that on average the size of the impact after a single modification (a change in a one EFSM transition) ranges between 14 and 38 % of the total size of the model. For a modification involving multiple transitions, the average size of the impact ranges between 30 and 64 % of the total size of the model. Additionally, we investigated the relationships (correlation) between the structure of the EFSM model, and the size of the impact sets. Upon preliminary analysis of the correlation, the concepts of model density and data density were defined, and it was found that they could be the major factors influencing the sizes of impact sets for models. As a result, these factors can be used to determine the types of models for which the proposed approach is the most appropriate.

Software maintenance is becoming more challenging with the increased complexity of the software and the frequently applied modifications. To manage this complexity, systems development is headed towards Model-driven engineering (MDE) and search-based software engineering (SBSE). Additionally, prior to applying a change to these complex systems, change impact analysis is usually performed in order to determine the scope of the change, its feasibility, and the time and resources required to implement the change. The bigger the scope, the riskier the change is on the system. In this paper, we introduce a set of transformation rules for Extended Finite State Machine (EFSM) models of state-based systems. These transformation rules can be used as the basis for search-based model optimization in order to reduce the average impact of a potential change applied to an EFSM model. Assuming that Model-driven development is adopted for the implementation of a state-based system, reducing the change impact at the model level will lead to reducing the impact at the system level. An exploratory study is performed to measure the impact reduction for a given EFSM model when the transformation rules are applied by a search-based algorithm. The initial results show a promising usage of the transformation rules which can lead to a reduction of more than 50% of the initial average change impact of the model.

System reliability has always been a challenging issue for many systems. In order to achieve high reliability, redundancy and voting schemes are often used to tolerate unintentional component failures. For unintentional failures caused by, for instance, normal wear-outs, hardware failures, or software bugs, etc., adding more redundancies often improves a system's reliability. However, when attack-caused failures exist, the number of redundant components and the number of participating voting entities may not be positively proportional to system reliability. In this paper, we study system reliability and system defense strategies when the system is under rational attacks. In particular, we analyze how defense and attack strategies may impact system reliability when both the defender and attacker are given a fixed amount of resources that can only be used for adding camouflaging components or enhancing existing components' cyber protection by defenders, or selecting a subset of components to attack by attackers, respectively. We also present an algorithm to decide the optimal defense strategy in fighting against rational attacks.

The 4th International Conference on Software Testing, Verification, and Validation (ICST 2011) was held on 21-25 March 2011, in Berlin, Germany. The aim of the ICST conference is to bring together researchers and practitioners who study the theory, techniques, technologies, and applications that concern all aspects of software testing, verification, and validation of software systems. The ICST 2011 program chairs, Mark Harman and Bogdan Korel, selected 35 research papers for inclusion in the proceedings from among 166 submissions. All papers were refereed by at least three program committee members. Of the 35 papers accepted, we selected six papers for consideration for this special issue of STVR. These papers were extended from their conference version by the authors and were reviewed according to the STVR reviewing process. Five papers successfully completed the review process and are contained in this special issue. These papers are spread across two special issues of STVR. This issue includes the first three papers. The rest of this editorial provides a brief overview of these three papers. The first paper, ‘Configuring Effective Navigation Models and Abstract Test Cases for Web Applications by Analyzing User Behavior’ by Sara Sprenkle, Lori Pollock and Lucy Simko, reports on an exploratory study of automatically generated abstract test cases and the underlying usage-based navigation models for Web applications. The results suggest that web testers can easily configure statistical model-based automated test generators to generate tests closely related to user behaviour. The second paper, ‘Testing of Data-Centric and Event-Based Dynamic Service Compositions’ by Waldemar Hummer, Orna Raz, Onn Shehory, Philipp Leitner, and Schahram Dustdar, investigates integration testing of data-centric and event-based dynamic service compositions with an emphasis on data-flow centric coverage goals. The evaluation of the presented approach for different performance characteristics demonstrates the end-to-end practicability of the approach. The third paper, ‘Demand-driven Propagation-based Strategies for Testing Changes’ by Raul Santelices and Mary Jean Harrold, presents a novel, demand-driven approach for performing the propagation-based testing of changes. The experimental study shows that the approach can be practical and can scale to large programs.

This is the second of two volumes of the Special Issue on Software Testing, Verification, and Validation (STVR). Five papers successfully completed the review process. These papers are spread across two special issues of STVR. The previous issue of STVR includes the first three papers. This issue includes the remaining two papers. The rest of this editorial provides a brief overview of these two papers. The first paper, ’Checked Coverage: An Indicator for Oracle Quality’ by David Schuler and Andreas Zeller, proposes an approach to assess oracle quality. The concept of checked coverage is introduced – the dynamic slice of covered statements. The results of the experimental study suggest that the checked coverage is a good indicator for oracle quality, The second paper, ’Handling Test Length Bloat’ by Gordon Fraser and Andrea Arcuri, investigates the effect of test length and bloat in the context of testing object-oriented software, where test cases are sequences of method calls. The bloat occurs when the test length abnormally grows over time during search-based test generation. Techniques to overcome the length bloat are presented. The results of an experimental study demonstrate that these techniques can improve the performance of the search process. In conclusion, we would like to thank the authors of this and the previous special issue for preparing the extended versions of the ICST-2011 conference papers. We are particularly thankful to all reviewers for timely and constructive reviews. Finally, we hope that this special issue will be stimulating for many practitioners and researchers and will help in advancing the knowledge and research in software testing, verification, and validation.

SUMMARY During regression testing, a modified system is often retested using an existing test suite. Since the size of the test suite may be very large, testers are interested in detecting faults in the modified system as early as possible during this retesting process. Test prioritization attempts to order tests for execution so that the chances of early detection of faults during retesting are increased. The existing prioritization methods are based on the source code of the system under test. In this paper, we present and evaluate two model‐based selective methods and a dependence‐based method of test prioritization utilizing the state‐based model of the system under test. These methods assume that the modifications are made both on the system under test and its model. The existing test suite is executed on the system model and information about this execution is used to prioritize tests. Execution of the model is inexpensive as compared with execution of the system under test; therefore, the overhead associated with test prioritization is relatively small. In addition, we present an analytical framework for evaluation of test prioritization methods. This framework may reduce the cost of evaluation as compared with the framework that is based on observation. We have performed an empirical study in which we compared different test prioritization methods. The results of the empirical study suggest that system models may improve the effectiveness of test prioritization with respect to early fault detection. Copyright © 2011 John Wiley & Sons, Ltd.

Mission critical systems often operate for limit time durations. For these systems, we subscribe to the notion that provisioning of security can be based on the expected duration of a system's mission. In this paper, we present a simple and safe K-variant approach to improve time-based mission critical systems' attack-survivability and provide formal analysis about K-variant system's attack survivability under M memory-based attack attempts. Our theoretical analysis supported by extensive simulations and a case study provide good evidences that the proposed approach may be in improving system's attack-survivability.

Assertions are used to detect incorrect program behavior during testing and debugging. Assertions when combined with automated test data generation may increase the confidence that certain types of faults are not present in the program. If the test data generation process is not able to violate an assertion, a developer may have confidence that the fault "captured" by the assertion is not present. We refer to this process as an assertion-based validation. Assertion-based validation may be very expensive especially when a large number of assertions are present in a program. During maintenance, after a modification is made to the program, all unchanged assertions need to be revalidated to make sure that certain types of faults are present. In this paper we present an approach that may reduce the cost of assertion-based revalidation after modifications are made to the program by identifying assertions that need to be revalidated or only partially revalidated. The presented approach is based on program dependence analysis and testability transformation. The results of a small case study indicate that the presented approach may significantly reduce the effort during the process of assertion-based revalidation.

During regression testing, a modified system needs to be retested using the existing test suite. Since test suites may be very large, developers are interested in detecting faults in the system as early as possible. Test prioritization orders test cases for execution to increase potentially the chances of early fault detection during retesting. Most of the existing test prioritization methods are based on the code of the system, but model-based test prioritization has been recently proposed. System modeling is a widely used technique to model state-based systems. The existing model based test prioritization methods can only be used when models are modified during system maintenance. In this paper, we present model-based prioritization for a class of modifications for which models are not modified (only the source code is modified). After identification of elements of the model related to source-code modifications, information collected during execution of a model is used to prioritize tests for execution. In this paper, we discuss several model-based test prioritization heuristics. The major motivation to develop these heuristics was simplicity and effectiveness in early fault detection. We have conducted an experimental study in which we compared model-based test prioritization heuristics. The results of the study suggest that system models may improve the effectiveness of test prioritization with respect to early fault detection.

During regression testing, a modified system is retested using the existing test suite. Because the size of the test suite may be very large, testers are interested in detecting faults in the system as early as possible during the retesting process. Test prioritization tries to order test cases for execution so the chances of early detection of faults during retesting are increased. The existing prioritization methods are based on the code of the system. System modeling is a widely used technique to model state-based systems. In this paper, we present methods of test prioritization based on state-based models after changes to the model and the system. The model is executed for the test suite and information about model execution is used to prioritize tests. Execution of the model is inexpensive as compared to execution of the system; therefore the overhead associated with test prioritization is relatively small. In addition, we present an analytical framework for evaluation of test prioritization methods. This framework may reduce the cost of evaluation as compared to the existing evaluation framework that is based on experimentation (observation). We have performed an experimental study in which we compared different test prioritization methods. The results of the experimental study suggest that system models may improve the effectiveness of test prioritization with respect to early fault detection.

Source-code based test data generation is a process of finding program input on which a selected element, e.g., a target statement, is executed. There exist many test generation methods that automatically find a solution to the test generation problem. The existing methods work well for many programs. However, they may fail or are inefficient for programs with complex logic and intricate relationships between program elements. In this paper we present a testability transformation that transforms programs so that the chances of finding a solution are increased when the existing methods fail using only the original program. In our approach data dependence analysis is used to identify statements in the program that affect computation of the fitness function associated with the target statement. The transformed program contains only these statements, and it is used to explore different ways the fitness may be computed. These explorations are inexpensive when using the transformed program as compared to explorations using the original program. As a result, executions in the transformed program that lead to the evaluation of the fitness function to the target value are identified. The identified executions are then used to guide the search in the original program to find an input on which the target statement is executed. In this paper, the approach is evaluated using a case study which demonstrates the potential for this testability transformation to improve the efficacy of the test generation

In systems developed without aspect-oriented programming, code implementing a crosscutting concern may be spread over many different parts of a system. Identifying such code automatically could be of great help during maintenance of the system. First of all, it allows a developer to more easily find the places in the code that must be changed when the concern changes and, thus, makes such changes less time consuming and less prone to errors. Second, it allows the code to be refactored to an aspect-oriented solution, thereby improving its modularity. In this paper, we evaluate the suitability of clone detection as a technique for the identification of crosscutting concerns. To that end, we manually identify five specific crosscutting concerns in an industrial C system and analyze to what extent clone detection is capable of finding them. We consider our results as a stepping stone toward an automated "aspect miner” based on clone detection.

Evolutionary testing is an effective technique for automatically generating good quality test data. However, for structural testing, the technique degenerates to random testing in the presence of flag variables, which also present problems for other automated test data generation techniques. Previous work on the flag problem does not address flags assigned in loops.This paper introduces a testability transformation that transforms programs with loop--assigned flags so that existing genetic approaches can be successfully applied. It then presents empirical data demonstrating the effectiveness of the transformation. Untransformed, the genetic algorithm flounders and is unable to find a solution. Two transformations are considered. The first allows the search to find a solution. The second reduces the time taken by an order of magnitude and, more importantly, reduces the slope of the cost increase; thus, greatly increasing the complexity of the problem to which the genetic algorithm can be applied. The paper also presents a second empirical study showing that loop--assigned flags are prevalent in real world code. They account for just under 11% of all flags.

System modeling is a widely used technique to model state-based systems. Several state-based languages are used to model such systems, e.g., EFSM (extended finite state machine), SDL (specification description language) and state charts. Although state-based modeling is very useful, system models are frequently large and complex and are hard to understand and modify. Slicing is a well-known reduction technique. Most of the research on slicing is code-based. There has been limited research on specification-based slicing and model-based slicing. In this paper, we present an approach to slicing state-based models, in particular EFSM models. Our approach automatically identifies the parts of the model that affect an element of interest using EFSM dependence analysis. Slice reduction techniques are then used to reduce the size of the EFSM slice. Our experience with the presented slicing approach showed that significant reduction of state-based models could be achieved.

Model based testing is a system testing technique used to test software systems modeled by formal description languages, e.g., an extended finite state machine (EFSM). System models are frequently changed because of specification changes. Selective test generation techniques are used to test the modified parts of the model. However, the size of regression test suites still may be very large. In this paper, we present a model-based regression testing approach that uses EFSM model dependence analysis to reduce regression test suites. The approach automatically identifies the difference between the original model and the modified model as a set of elementary model modifications. For each elementary modification, regression test reduction strategies are used to reduce the regression test suite based on EFSM dependence analysis. Our initial experience shows that the approach may significantly reduce the size of regression test suites.

In this paper we describe a technique for generating expected results for automated black-box testing. Generating expected results allows larger automated test suites to be created, moving us toward continuous product testing. Our technique uses a program's Input-Output (IO) relationships to identify unique combinations of program inputs that influence program outputs. With this information, a small set of test cases is executed and checked for correctness. Given the correctness of this set, the expected results for the larger combinatorial test set can be generated automatically. Included in the paper is an experimental study in which checking the results of 384 test cases allows us to generate expected results and fully automate nearly 600,000 test cases.

Testing large software systems is very laborious and expensive. Model-based test generation techniques are used to automatically generate tests for large software systems. However, these techniques require manually created system models that are used for test generation. In addition, generated test cases are not associated with individual requirements. In this paper, we present a novel approach of requirement-based test generation. The approach accepts a software specification as a set of individual requirements expressed in textual and SDL formats (a common practice in the industry). From these requirements, system model is automatically created with requirement information mapped to the model. The system model is used to automatically generate test cases related to individual requirements. Several test generation strategies are presented. The approach is extended to requirement-based regression test generation related to changes on the requirement level. Our initial experience shows that this approach may provide significant benefits in terms of reduction in number of test cases and increase in quality of a test suite.

Test reduction is an important issue in black-box testing. The number of possible black-box tests for any non-trivial software application is extremely large. For the class of programs with multiple inputs and outputs, the number of possible tests grows very rapidly as combinations of input test data are considered. In this paper, we introduce an approach to test reduction that uses automated input-output analysis to identify relationships between program inputs and outputs. Our initial experience with the approach has shown that it can significantly reduce the number of black-box tests.

Regression testing involves testing the modified program in order to establish the confidence in the modifications. Existing regression testing methods generate test cases to satisfy selected testing criteria in the hope that this process may reveal faults in the modified program. In this paper we present a novel approach of automated regression test generation in which all generated test cases uncover an error(s). This approach is used to test the common functionality of the original program and its modified version, i.e., it is used for programs whose functionality is unchanged after modifications. The goal in this approach is to identify test cases for which the original program and the modified program produce different outputs. If such a test is found, then this test uncovers an error. The problem of finding such a test case may be reduced to the problem of finding program input on which a selected statement is executed. As a result, existing methods of automated test data generation for white-box testing may be used to generate these tests. Our experiments have shown that our approach may improve the chances of finding software errors as compared to the existing methods of regression testing. The advantage of our approach is that it is fully automated and that all generated test cases reveal an error(s).

A dynamic program slice is an executable part of the program whose behaviour is identical, for the same program input, to that of the original program with respect to a variable(s) of interest at some execution position. The existing algorithms of dynamic slice computation use data and control dependencies to compute dynamic slices. These algorithms are limited to structured programs because they may compute incorrect dynamic slices for unstructured programs, due to the limitations of control dependencies that are used to compute dynamic slices. In this paper, we present a novel approach to dynamic slice computation for unstructured programs. The approach employs the notion of a removable block in finding dynamic program slices. Dynamic slices are derived by identifying not only those parts of program execution that contribute to the computation of the value of a variable of interest, but also those parts of program execution that do not contribute to the computation of the variable value. Data dependencies are used to identify contributing computations, whereas removable blocks are used to identify noncontributing computations. We have proved that the presented dynamic slicing algorithms correctly compute dynamic slices. In addition, these algorithms may compute more accurate dynamic slices compared to existing algorithms that use control dependencies. The presented algorithms have been implemented in a tool that supports dynamic slicing for Pascal programs.

Test data generation in program testing is the process of identifying a set of test data that satisfies a selected testing criterion, such as, statement coverage or branch coverage. The existing methods of test data generation are limited to unit testing and may not efficiently generate test data for programs with procedures. In this paper we present an approach for automated test data generation for programs with procedures. This approach builds on the current theory of execution-oriented test data generation. In this approach, test data are derived based on the actual execution of the program under test. For many programs, the execution of the selected statement may require prior execution of some other statements that may be part of some procedures. The existing methods use only control flow information of a program during the search process and may not efficiently generate test data for these types of programs because they are not able to identify statements that affect execution of the selected statement. Our approach uses data dependence analysis to guide the process of test data generation. Data dependence analysis automatically identifies statements (or procedures) that affect the execution of the selected statement and this information is used to guide the search process. The initial experiments have shown that this approach may improve the chances of finding test data.

Software testing is very labor intensive and expensive and accounts for a significant portion of software system development cost. If the testing process could be automated, the cost of developing software could be significantly reduced. Test data generation in program testing is the process of identifying a set of test data that satisfies a selected testing criterion, such as statement coverage and branch coverage. In this article we present achaining approachfor automated software test data generation which builds on the current theory of execution-oriented test data generation. In the chaining approach, test data are derived based on the actual execution of the program under test. For many programs, the execution of the selected statement may require prior execution of some other statements. The existing methods of test data generation may not efficiently generate test data for these types of programs because they only use control flow information of a program during the search process. The chaining approach uses data dependence analysis to guide the search process, i.e., data dependence analysis automatically identifies statements that affect the execution of the selected statement. The chaining approach uses these statements to form a sequence of statements that is to be executed prior to the execution of the selected statement. The experiments have shown that the chaining approach may significantly improve the chances of finding test data as compared to the existing methods of automated test data generation.

Software testing, specifically, test data generation is very labor-intensive and expensive. As a result, it accounts for a significant portion of software system development cost. In this paper we present a chaining approach for automated software test data generation. The chaining approach uses data dependence analysis to guide the test data generation process. The experiments have shown that the chaining approach may significantly improve the chances of finding test data as compared to the existing methods of automated test data generation.

A dynamic program slice is an executable part of the program whose behavior is identical, for the same program input, to that of the original program with respect to a variable(s) of interest at some execution position. It has been shown that dynamic slicing is useful for the purpose of debugging, testing and software maintenance. The existing methods of dynamic slice computation are based on “backward” analysis, i.e., after the execution trace of the program is first recorded, the dynamic slice algorithm traces backwards the execution trace to derive dynamic dependence relations that are then used to compute dynamic slices. For many programs, during their execution extremely high volume of information may be recorded that may prevent accurate dynamic slice computation. In this paper we present a novel approach of dynamic slice computation, referred to as forward approach of dynamic slice computation. In this method, dynamic slices are computed during program execution without major recording of the execution trace. The major advantage of the forward approach is that space complexity is bounded as opposed to the backward methods of slice computation.

An approach to automated timing analysis of distributed real-time programs is presented. The method is based on the static analysis of the task system and generation of global operation (GO) paths for which the timing analysis is applied. It is shown that a closed form solution algorithm is NP-complete. In order to more efficiently determine maximum waiting times for tasks sharing resources, even for large programs with many tasks, a reduced flow graph problem is defined by neglecting the differences in the execution times of the local operations. A solution for this problem gives an upper bound for the original analysis problem. A conjecture that the reduced problem is NP-complete even for two tasks is disproved by giving a formally correct polynomial time solution algorithm. The maximum number of steps for computing the maximum waiting for the reduced problem is linear with respect to the numbers of task's server requests.>

Abstract Test data generation in program testing is the process of identifying a set of test data which satisfies a given testing criterion. Existing pathwise test data generators proceed by selecting program paths that satisfy the selected criterion and then generating program inputs for these paths. One of the problems with this approach is that unfeasible paths are often selected; as a result, significant computational effort can be wasted in analysing those paths. In this paper, an approach to test data generation, referred to as a dynamic approach for test data generation, is presented. In this approach, the path selection stage is eliminated. Test data are derived based on the actual execution of the program under test and function minimization methods. The approach starts by executing a program for an arbitrary program input. During program execution for each executed branch, a search procedure decides whether the execution should continue through the current branch or an alternative branch should be taken. If an undesirable execution flow is observed at the current branch, then a real‐valued function is associated with this branch, and function minimization search algorithms are used to locate values of input variables automatically, which will change the flow of execution at this branch.

A novel approach to automating test data generation for distributed programs is presented. The approach is based on actual execution of the program under test, a run-time scheduler, function minimization methods, and dynamic dataflow analysis. Test data are developed for the program using actual values of the input variables. When the program is executed, the program execution flow is monitored. If during program execution an undesirable execution flow is observed then function minimization search algorithms are used to automatically locate the values of input variables for which the selected path is traversed. In addition, dynamic dataflow analysis is used to determine those input variables responsible for the undesirable program behavior, which can lead to significant speed-up of the search process.>

The authors describe the file management system of DRAGON SLAYER, a distributed operating system which provides transparent resource sharing in a heterogeneous local area network with completely decentralized control. Users are able to use any of the system files for which they have authorization, without regard to the individual characteristics of the computers on which the files reside or the physical locations of the users and files. In addition, files can be dynamically fragmented, and the fragments can be replicated and relocated dynamically. Copies are kept mutually consistent while all file operations work either transparently on the whole file or on specific fragments. The DRAGON SLAYER resource management supporting these file system operations is presented. Beyond the obvious advantages of file access reliability and flexibility, the authors present simulation results proving the superior performance of this file system as compared with conventional distributed file systems with non-fragmented files.>

The author presents a dynamic approach to test data generation, in which the path selection stage is eliminated. In this approach, test data are derived on the basis of the actual execution of the program under test, of dynamic data flow analysis, and of function minimization methods. The approach starts by executing a program for an arbitrary program input. During program execution for each executed branch, a search procedure decides whether the execution should continue the current branch or whether an alternative branch should be taken. If an undesirable execution flow is observed at the current branch, then a real-valued function is associated with this branch, and function minimization search algorithms are used to automatically locate values of input variables which will change the flow of execution at this branch. In addition, dynamic data flow analysis is used to determine input variables which are responsible for the undesirable program behavior, leading to speedup of the search process.>

An alternative approach to test-data generation based on actual execution of the program under test, function-minimization methods and dynamic data-flow analysis is presented. Test data are developed for the program using actual values of input variables. When the program is executed, the program execution flow is monitored. If during program execution an undesirable execution flow is observed then function-minimization search algorithms are used to automatically locate the values of input variables for which the selected path is traversed. In addition, dynamic data-flow analysis is used to determine those input variables responsible for the undesirable program behavior, significantly increasing the speed of the search process. The approach to generating test data is then extended to programs with dynamic data structures and a search method based on dynamic data-flow analysis and backtracking is presented. In the approach described, values of array indexes and pointers are known at each step of program execution; this information is used to overcome difficulties of array and pointer handling.>

An experimental distributed system based on an integrated system design was built that incorporates user-level or environmental application requirements into the design issues of the distributed operating system Dragon Slayer. The key for making use of the Dragon Slayer services, in supporting applications requesting a high amount of reliability under completely decentralized control, is the definition of the concept of distributed objects. These were used as the basis for a paradigm of distributed computing that allows users to neglect the distribution of services and responses. How distributed objects are managed in Dragon Slayer is outlined. The distributed objects are logical objects which may be partitioned. The parts or fractions may be distributed over several nodes. They may even exist in multiple copies or version. In order to prepare the ground for requirements regarding distributed object management, a taxonomy of object-oriented approaches and their methods of managing distributed object operations is given. A set of necessary conditions for the design of distributed operating system services that are to support such management methods under completely decentralized control is determined.>

Error localization in program debugging is the process of identifying program statements which cause incorrect behavior. A prototype of the error localization assistant system which guides a programmer during debugging of Pascal programs is described. The system is interactive: it queries the programmer for the correctness of the program behavior and uses answers to focus the programmer's attention on an erroneous part of the program (in particular, it can localize a faulty statement). The system differs from previous approaches in that it makes use of the knowledge of program structure, which is derived automatically. The knowledge of program structure is represented by the dependence network which is used by the error-locating reasoning mechanism to guide the construction, evaluation, and modification of hypothesis of possible causes of the error. Backtracking reasoning has been implemented in the reasoning mechanism.>

Some properties of a program data flow can be used to guide program testing. The presented approach aims to exercise use-definition chains that appear in the program. Two such data oriented testing strategies are proposed; the first involves checking liveness of every definition of a variable at the point(s) of its possible use; the second deals with liveness of vectors of variables treated as arguments to an instruction or program block. Reliability of these strategies is discussed with respect to a program containing an error.