jPET: An Automatic Test-Case Generator for Java

Abstract

Abstract-We present jPET, a whitebox test-case generator (TCG) which can be used during software development of Java applications within the Eclipse environment. jPET builds on top of PET, a TCG which automatically obtains test-cases from the bytecode associated to a Java program. jPET performs reverse engineering of the test-cases obtained at the bytecode level by PET in order to yield this information to the user at the source code level. This allows understanding the information gathered at the lower level and using it to test source Java programs.

Combining symbolic execution and search-based testing for programs with complex heap inputs

“…Symbolic execution tools like JPF [53], jPET [1], JBSE [10,11] and BLISS [53] straightforwardly instantiate the input objects in the heap memory, and set the initial state by directly manipulating their internal fields. Figure 4 shows a test case generated from the path condition in Figure 3 by directly instantiating the objects in the heap and manipulating their fields.…”

“…This paper presented SUSHI, a test case generation approach that benefits from a novel combination of symbolic execution and searchbased techniques, to overcome a crucial limitation of many test generation approaches that rely on directly manipulating the heap memory to construct the input structures [1,7,33,38,48,53]. Directly manipulating the heap may result in test cases that the developers can hardly understand and trust, especially when dealing with programs with complex ad-hoc data structures.…”

“…Symbolic techniques, like JPF [53], jPET [1], JBSE [10,11], and BLISS [48], identify input states to execute code elements, but rely on direct heap manipulation to instantiate the data structures that comprise these input states. Test cases that instantiate the input data structures by directly manipulating the heap memory may either not compile, since they directly access private fields, or create unreachable program states, since they bypass the program functions that preserve the invariants [17], and are often hardly readable and understandable by developers [18].…”

“…Many symbolic executors can effectively handle programs that take primitive inputs [4,5,8,12,13,34,49,54], but only some can efficiently reason on input data structures as well [1,10,20,48,51,53]. Some approaches combine symbolic execution with search-based techniques.…”

“…They either instantiate the input data structures by directly manipulating the heap memory [1,10], or rely on static analysis to build sequences of interface method invocations that produce the input structures that satisfy the path conditions [50,51]. Approaches that rely on static analysis successfully identify some combinations of constructors and methods that instantiate simple input structures, but often fail in the presence of inter-procedural relations that depend on complex input structures, due to imprecision and inefficiency of static analysis.…”