Huo Yan Chen

In black and white: an integrated approach to class-level testing of object-oriented programs

Because of the growing importance of object-oriented programming, a number of testing strategies have been proposed. They are based either on pure black-box or white-box techniques. We propose in this article a methodology to integrate the black- and white-box techniques. The black-box technique is used to select test cases. The white-box technique is mainly applied to determine whether two objects resulting from the program execution of a test care are observationally equivalent. It is also used to select test cases in some situations. We define the concept of a fundamental pair as a pair of equivalent terms that are formed by replacing all the variables on both sides of an axiom by normal forms. We prove that an implementation is consistent with respect to all equivalent terms if and only if it is consistent with respect to all fundamental pairs. In other words, the testing coverage of fundamental pairs is as good as that of all possible term rewritings, and hence we need only concentrate on the testing of fundamental pairs. Our strategy is based on mathematical theorems. According to the strategy, we propose an algorithm for selecting a finite set of fundamental pairs as test cases. Given a pair of equivalent terms as a test case, we should then determine whether the objects that result from executing the implemented program are observationally equivalent. We prove, however, that the observational equivalence of objects cannot be determined using a finite set of observable contexts (which are operation sequences ending with an observer function) derived from any black-box technique. Hence we supplement our approach with a “relevant observable context” technique, which is a heuristic white-box technique to select a relevant finite subset of the set of observable contexts for determining the observational equivalence. The relevant observable contezxts are constructed from a data member relevance graph (DRG), which is an abstraction of the given implementation for a given specificatin. A semiautomatic tool hass been developed to support this technique.

TACCLE: a methodology for object-oriented software testing at the class and cluster levels

Object-oriented programming consists of several different levels of abstraction, namely, the algorithmic level, class level, cluster level, and system level. The testing of object-oriented software at the algorithmic and system levels is similar to conventional program testing. Testing at the class and cluster levels poses new challenges. Since methods and objects may interact with one another with unforeseen combinations and invocations, they are much more complex to simulate and test than the hierarchy of functional calls in conventional programs. In this paper, we propose a methodology for object-oriented software testing at the class and cluster levels. In class-level testing, it is essential to determine whether objects produced from the execution of implemented systems would preserve the properties defined by the specification, such as behavioral equivalence and nonequivalence. Our class-level testing methodology addresses both of these aspects. For the testing of behavioral equivalence, we propose to select fundamental pairs of equivalent ground terms as test cases using a black-box technique based on algebraic specifications, and then determine by means of a white-box technique whether the objects resulting from executing such test cases are observationally equivalent. To address the testing of behavioral nonequivalence, we have identified and analyzed several nontrivial problems in the current literature. We propose to classify term equivalence into four types, thereby setting up new concepts and deriving important properties. Based on these results, we propose an approach to deal with the problems in the generation of nonequivalent ground terms as test cases. Relatively little research has contributed to cluster-level testing. In this paper, we also discuss black-box testing at the cluster level. We illustrate the feasibility of using contract, a formal specification language for the behavioral dependencies and interactions among cooperating objects of different classes in a given cluster. We propose an approach to test the interactions among different classes using every individual message-passing rule in the given Contract specification. We also present an approach to examine the interactions among composite message-passing sequences. We have developed four testing tools to support our methodology.

ROCS: an object-oriented class-level testing system based on the Relevant Observable ContextS technique☆

Given an algebraic specification of a class of objects, we define a fundamental pair as two equivalent terms generated by substituting all the variables on both sides of an axiom by normal forms. For any implementation error in the class, if it can be revealed by two equivalent terms in general, it can also be revealed by a fundamental pair. Hence, we need only select test cases from the set of fundamental pairs instead of equivalent pairs in general. We highlight an algorithm for selecting a finite set of fundamental pairs as test cases. Further, by using the relevant observable contexts technique, we highlight another algorithm to determine whether the objects resulting from executing a fundamental pair are observationally equivalent. If not, it reveals an implementation error. Using these algorithms, we have constructed a system to test object-oriented programs at class-level. We describe in detail the implementation of a prototype system, including the data structure of a Data member Relevant Graph (DRG) for the class, the procedures for the construction and path traversal of the DRG, the generation and execution of relevant observable contexts on the objects under test, and the reporting of implementation errors. The implementation illustrates an innovative idea of embedding testing algorithms into an interpreter to facilitate software testing.

A Tool to Support Automated Testing for Web Application Scenario

Web applications are becoming increasingly complex and important for companies. Their development, including analysis, design, and testing, needs to be approached by means of support tools. There are some tools provided to support analysis and design. However, few tools are provided to directly support the software testing on Web-based applications. In this paper, a software tool, named WASATT (Web application scenario automated testing tool), is proposed to support the automated testing for scenario of Web-based applications. Testers can create or ask analyst to create extended activity diagram model, which extends the semantics of UML standard activity diagram and can precisely express functional scenario of web applications. Then the extended activity diagram model can be transformed to testing code based on HttpUnit by WASATT. The tool can elevate the automated level of functional testing for Web applications.

The application of Prolog to structured design

In this paper, we investigate the feasibility of applying logic programming to structured design. We propose to use Prolog as a common machinery for the representation of various structured tools. We illustrate through examples how to produce structure charts from data flow diagrams, and evaluate them according to commonly recommended design guidelines. If the structure charts produced are not satisfactory, the inherent backtracking mechanism in Prolog will help to produce other versions for further evaluation.

A framework of reachability testing for Java multithread programs

The nondeterministic behavior of concurrent software makes the results of its running and testing uncertain. So it is difficult to debug and test concurrent software. Reachability testing is an effective method for concurrent software testing. This paper presents a framework for selecting synchronization sequences from Java multithread program based on the analysis of reading and writing shared variables. Our framework consists of a strategy for generating synchronization sequence set of reachability testing, and an approach for deterministic testing of the synchronization sequences. A prototype for reachability testing of Java multithread program has been developed. In the prototype, a dynamic proxy class is used to implement a deterministic testing framework of Java multithread program.

An approach for object-oriented cluster-level tests based on UML

We proposed a systematic methodology TACLLE for testing object-oriented software at class-and cluster-levels, which has been published in ACM Transactions on Software Engineering and Methodology (vol.10, no.1, p.56-109, 2001). The methodology for cluster-level is based on contract specification for message passing across different classes in the given cluster. Recent years, more and more software developers use UML (Unified Modeling Language) and corresponding visual modeling tools to develop their application software. We discuss how to use our TACCLE methodology to test UML-based software at cluster-level. In UML model, message passing across different classes in a given use case is described by interaction diagram, i.e. sequence diagram or collaboration diagram. A use case corresponds to a luster. We present a set of guidelines to guide the tester to transform the given sequence diagram or collaboration diagram for a given use case into corresponding contract specification CnSp. By means of the CnSp, our TACCLE methodology can be used to test the implementation of the cluster corresponding to the given use case.

Equality to Equals and Unequals: A Revisit of the Equivalence and Nonequivalence Criteria in Class-Level Testing of Object-Oriented Software

Algebraic specifications have been used in the testing of object-oriented programs and received much attention since the 1990s. It is generally believed that class-level testing based on algebraic specifications involves two independent aspects: the testing of equivalent and nonequivalent ground terms. Researchers have cited intuitive examples to illustrate the philosophy that even if an implementation satisfies all the requirements specified by the equivalence of ground terms, it may still fail to satisfy some of the requirements specified by the nonequivalence of ground terms. Thus, both the testing of equivalent ground terms and the testing of nonequivalent ground terms have been considered as significant and cannot replace each other. In this paper, we present an innovative finding that, given any canonical specification of a class with proper imports, a complete implementation satisfies all the observationally equivalent ground terms if and only if it satisfies all the observationally nonequivalent ground terms. As a result, these two aspects of software testing cover each other and can therefore replace each other. These findings provide a deeper understanding of software testing based on algebraic specifications, rendering the theory more elegant and complete. We also highlight a couple of important practical implications of our theoretical results.

Lean Implementations of Software Testing Tools Using XML Representations of Source Codes

By utilizing XML representations of source programs under test, a new approach is proposed to concisely implement some prototypes for TACCLE, a software testing methodology. The conversions between a source program and its XML representation can be easily realized using existing conversion tools. In this way, the conversion tools can automatically analyze and parse the source program, so that testing tool developers only need to concentrate on the manipulation of the XML document. If appropriate XML DOM APIs are chosen, the implementations of such testing tools will be pretty lean. A detailed case study for GMPS tool, a prototype for the TACCLE methodology, is presented to illustrate the new approach.

A semi-automatic generator for unit testing code files based on JUnit

JUnit is the de facto standard platform for Java unit testing. When we apply JUnit to put unit testing into practice, we should write some testing files, which obey the JUnit rules. These testing files have similar structure and similar codes. If we have to test a great amount of Java source files, according to the rules of JUnit, we must write almost the same amount of testing files. That is tedious work, and would cost much time and energy. This paper presents a semi-automatic generator of unit testing code files, which are derived from given Java source code files. The generator is constructed by analyzing the structure and rules of JUnit and applying reflection technique of Java language. It can alleviate testers burden, and improve the efficiency and velocity of unit test.