Lecture Notes in Computer Science 3472

12.5 Summary
12 Technology of Test-Case Generation 353
In this chapter we have shown how the search problem of finding test cases
that satisfy given test case specifications can be solved by applying well known
techniques from computer science. After introducing the basic terminology and
the used formalisms in each section, we have shown how techniques and tools
from theorem proving, symbolic execution, andmodel checking can be applied to
perform, improve, or support test case generation based on a model of the SUT.
At first, we have presented some approaches from the literature of how test
case generation can be done by theorem proving. A formal specification of the
SUT is transformed into equivalence classes, which are assumed to represent
the same behavior with respect to the test. Therefore, each equivalence class
can be interpreted as one test case. We have shown how such transformations
into equivalence classes resp. partitions can be performed using theorem proving
technology. In particular, we described how general purpose theorem provers can
be applied to generate test cases from Z specifications. Starting at the purely
syntactic disjunctive normal form approach, we have shown how to integrate semantic
aspects by means of the classification-tree method, and how partitioning
resp. fault-based heuristics can be used. Afterwards, we have covered test case
generation by logic programming, i.e., we have shown how algebraic specifications
can be translated into Horn clauses from which test cases can be extracted
by Prolog’s resolution principle. Finally, we have shortly described test case
extraction from correctness proofs. Topics for future research in this area are
extensions regarding test case sequencing and concurrency, broader constraint
solving abilities, and applications to a wider range of graphical notations.
We have also shown that symbolic execution is a relevant technique to help
coping with state space explosion while generating test cases. Symbolic execution
is generic enough to be applied to abstract models as well as to concrete code.
In particular, we have described three test case generation frameworks. The first
two start by performing a translation of their respective abstract models (in the
B and AUTOFOCUS modelling language) into a constraint logic programming
language. The resulting CLP model is then symbolically executed in order to
search for traces that represent interesting test cases. In both examples a synergy
between symbolic execution and theorem proving is established, given that logic
programming is used to perform state space exploration. The third example
framework demonstrates generating test cases starting from Java code. A very
interesting feature of this approach is that it uses model checking to symbolically
search the state space. In a way, this example comes to reinforce the notion that
symbolic execution is not used on its own to generate test cases – rather it is
merged with other techniques in order to overcome their shortfalls, as well the
ones in symbolic execution itself.
Finally, we have shortly described the application of model checking in modelbased
test case generation. Specifically, we have covered the relation between control
flow resp. data flow oriented coverage criteria and the capability of model
checkers to construct witnesses and counterexamples. There still remain a number
of open questions in this context. Most research efforts in model checking