István Forgács

An efficient relevant slicing method for debugging

Dynamic program slicing methods are widely used for debugging, because many statements can be ignored in the process of localizing a bug. A dynamic program slice with respect to a variable contains only those statements that actually had an influence on this variable. However, during debugging we also need to identify those statements that actually did not affect the variable but could have affected it had they been evaluated differently. A relevant slice includes these potentially affecting statements as well, therefore it is appropriate for debugging. In this paper a forward algorithm is introduced for the computation of relevant slices of programs. The space requirement of this method does not depend on the number of different dynamic slices nor on the size of the execution history, hence it can be applied for real size applications.

Feasible test path selection by principal slicing

We propose to improve current path-wise methods for automatic test data generation by using a new method named principal slicing. This method statically derives program slices with a near minimum number of influencing predicates, using both control and data flow information. Paths derived on principal slices to reach a certain program point are therefore very likely to be feasible. We discuss how our method improves on earlier proposed approaches, both static and dynamic. We also provide an algorithm for deriving principal slices. Then we illustrate the application of principal slicing to testing, considering a specific test criterion as an example, namely branch coverage. The example provided is an optimised method for automated branch testing: not only do we use principal slicing to obtain feasible test paths, but also we use the concept of spanning sets of branches to guide the selection of each next path, which prevents the generation of redundant tests.

An applicable test data generation algorithm for domain errors

An integrated testing criterion is proposed that extends traditional criteria to be effective to reveal domain errors. The method requires many fewer test cases and is applicable for any kind of predicates. An automated test data generation algorithm is developed to satisfy the criterion. This is the first integrated algorithm that unites path selection and test data generation. The method is based on function minimization and is extended to find required test cases corresponding to ON-OFF points very quickly. In this way the algorithm is dynamic and thus can be used in practice.

A demand-driven approach to slicing legacy COBOL systems

Maintenance of aging legacy COBOL systems is labor‐intensive and is becoming a more and more difficult problem. Program slicing is a potentially useful analysis for aiding different maintenance activities, including program comprehension, reverse engineering, debugging, and testing. Numerous techniques have been proposed in the past decades; however, in interactive contexts, we found none of them suitable for slicing industrial‐scale COBOL systems due to their large space or preprocessing requirements. This paper proposes a novel static program slicing approach, which is based on context‐sensitive token propagation over control flow graphs (CFGs). CFGs require less space compared with program dependence graphs (PDGs) used by other techniques, and the token propagation method computes the necessary information only, on demand. Algorithms are presented for data flow and full slicing to calculate precise program slices. Preliminary application experiences on industrial‐scale COBOL systems are also summarized. Copyright

Preventing untestedness in data‐flow based testing

A large number of path‐oriented testing criteria have been proposed in the last twenty years. Surprisingly, almost all of them suffer from a serious weakness, which is called the untestedness syndrome: even though a criterion is satisfied, some statements of the program under test may remain ‘untested’, i.e., the observed test output does not depend on them. A new data‐flow based testing criterion is introduced which does not suffer from untestedness, called the All Program Function (APF) criterion. Intuitively, it requires that each possible computation to every output statement in a program be covered by some test; but for lots of programs APF would require an infinite number of tests. A second, applicable criterion is thus introduced, derived from APF and called the Basic Program Function (BPF) criterion. BPF leaves no statement untested and yields finite test suites. Some examples show the application of BPF and investigate the failure‐detection capability of the proposed criterion. Copyright

An automatic approach of domain test data generation

Abstract It is usually observed in software testing that input data near the boundary of a domain partition are more sensitive to program faults and should be carefully checked. A formalization of this intuitive observation is domain testing. However, as an implementable testing technique, it has some difficulties. One of which is related to the test data generation. Since domain testing requires that the ON and OFF points be exactly on or near the boundary of a path domain, they can hardly be given manually. But how to automatically generate these test points efficiently is unclear. Traditionally there exist two different ideas. One is to use a static approach that computes the ON and OFF points by a series of algebraic operations. The other is to use a dynamic “search” method that determines an ON point in a “trial-and-error” manner. Each has its advantages and weaknesses. In this paper, we present a combined approach that takes the advantages of both ideas, i.e., it has both algebraic manipulations and a dynamic “search” process in a mixed way. It is shown that this approach is more efficient than others.

Double iterative framework for flow-sensitive interprocedural data flow analysis

Compiler optimization, parallel processing, data flow testing, and symbolic debugging can benefit from interprocedural data flow analysis. However, the live, reaching definition, and most summary data flow problems are theoretically intractable in the interprocedural case. A method is presented that reduces the exponential time bound with the help of an algorithm that solves the problem in polynomial time. Either the resulting sets contain precise results or the missing (or additional) results do not cause any problems during their use. We also introduce the double iterative framework, where one procedure is processed at a time. The results of the intraprocedural analysis of procedures then propagates along the edges of the call multi-graph. In this way the intra and interprocedural analyses are executed alternately until there is no change in any result set. This method can be applied to any known interprocedural data flow problem. Here the algorithms for the kill, live variables, and reaching definitions problems are presented. Besides for precision, the algorithms can be used for very large programs, and since inter and intraprocedural analyses can be optimized separately, the method is fast as well.

An exact array reference analysis for data flow testing

Data-flow testing is a well-known technique, and it has proved to be better than the commercially-used branch testing. The problem with data-flow testing is that, apart from scalar variables, only approximate information is available. This paper presents an algorithm that precisely determines the definition-use pairs for arrays within a large domain. There are numerous methods addressing the array data-flow problem; however, these methods are only used in the optimization or parallelization of programs. Data-flow testing, however, requires at least one real solution of the problem for which the necessary program path is executed. Contrary to former precise methods, we avoid negation in formulae, which seems to be the biggest problem in all previous methods.

A precise demand-driven definition-use chaining algorithm

This paper describes a new demand-driven technique that is able to identify both direct and indirect realizable data-dependencies between statements in the investigated code. Our method also involving control-dependencies and can thus be extended to perform precise forward and backward slicing of computer programs. The interprocedural algorithm presented considers realizable program paths when exploring individual definition-use chains by introducing backtrack information for traditional reaching definitions. Hence, our method is able to reveal deep and accurate information about very large programs on demand that makes it effectively applicable in either regression testing, debugging and program analysis.

Regression slicing and its use in regression testing

We introduce an improved software regression testing method that determines the test cases that must be rerun to fulfil a given testing criterion. The key part of our method is regression slicing. A regression slice contains the statements whose state may be changed in the modified program with respect to the original for a given test case.