This article describes a new approach to the unit testing of object-oriented programs, a set of tools based on this approach, and two case studies. In this approach, each test case consists of a tuple of sequences of messages, along with tags indicating whether these sequences should put objects of the class under test into equivalent states and\or return objects that are in equivalent states. Tests are executed by sending the sequences to objects of the class under test, then invoking a user-supplied equivalence-checking mechanism. This approach allows for substantial automation of many aspects of testing, including test case generation, test driver generation, test execution, and test checking. Experimental prototypes of tools for test generation and test execution are described. The test generation tool requires the availability of an algebraic specification of the abstract data type being tested, but the test execution tool can be used when no formal specification is available. Using the test execution tools, case studies involving execution of tens of thousands of test cases, with various sequence lengths, parameters, and combinations of operations were performed. The relationships among likelihood of detecting an error and sequence length, range of parameters, and relative frequency of various operations were investigated for priority queue and sorted-list implementations having subtle errors. In each case, long sequences tended to be more likely to detect the error, provided that the range of parameters was suffkiently large and likelihood of detecting an error tended to increase up to a threshold value as the parameter range increased. Categories and Subject Descriptors: D.2.1 [Software Engineering]: Requirements/Specificstions—languages; D.2.5 [Software Engineering]: Testing and Debugging-symbolzc execution;

We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it proposes equations. Finally, the tool generalizes equations to axioms and eliminates many redundant axioms. Since our tool uses dynamic information, it is not guaranteed to be sound or complete. However, we manually inspected the axioms generated in our experiments and found them all to be correct.

Modern programs make extensive use of reusable software libraries. For example, we found that 17 % to 30 % of the classes in a number of large Java applications use the container classes from the java.util package. Given this extensive code reuse in Java programs, it is important for the reusable interfaces to have clear and unambiguous documentation. Unfortunately, most documentation is expressed in English, and therefore does not always satisfy these requirements. Worse yet, there is no way of checking that the documentation is consistent with the associated code. Formal specifications present an alternative which does not suffer from these problems; however, formal specifications are notoriously hard to write. To alleviate this difficulty, we have implemented a tool which automatically derives documentation in the form of formal specifications. Our tool probes Java classes by invoking them on dynamically generated tests and captures the information observed during their execution as algebraic axioms. While the tool is not complete or correct from a formal perspective we demonstrate that it discovers many useful axioms when applied to container classes. These axioms then form an initial formal documentation of the class they describe. 1

Navigation is a fundamental human activity and an integral part of everyday life. Humans use their knowledge about previous experiences with geographic space to find their way. Considerable research in the areas of cognitive science, psychology, and artificial intelligence has been carried out to examine the means by which humans navigate. Humans need to abstract from reality and form concepts of space in order to reason about space or carry out tasks e.g., navigating. Concepts are used to organize space and to structure the perception of reality. They depend strongly on the knowledge of the human and on the task at hand. Humans may use multiple levels of abstraction, representing different parts of geographic space, to carry out a single navigation task. Although descriptions of spatial concepts already exist, they are defined in natural language and, therefore, lack the formality to be implemented. Conceptual modeling is a design technique that models the concepts of an application (e.g., highway navigation) on a highly abstracted level. Conceptual models provide the possibility to communicate spatial concepts in a formal and unambiguous way. For large and complex applications in Geographic Information Systems, conceptual modeling is a promising

Modern programs make extensive use of reusable software libraries. For example, a study of a number of large Java applications shows that between 17 % and 30 % of the classes in those applications use the container classes from the java.util package. Given this extensive code reuse in Java programs, it is important for the reusable interfaces to have clear and unambiguous documentation. Unfortunately, most documentation is expressed in English, and therefore does not always satisfy the above requirements. Worse yet, there is no way of checking that the documentation is consistent with the associated code. Formal specifications, such as algebraic specifications, do not suffer from these problems; however, they are notoriously hard to write. To alleviate this difficulty we describe a tool that automatically derives documentation for interfaces of Java classes. Our tool probes Java classes by invoking them on dynamically generated tests and captures the information observed during their execution as algebraic axioms. While the tool is not complete or correct from a formal perspective we demonstrate that it significantly alleviates the task of writing formal documentation for reusable components. 1