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.

Testing is an important means to ensure the quality of software systems. Contract specification can be used to formally specify the cluster level of object-oriented software, which can then be tested using TACCLE, an advanced methodology for object-oriented testing. The use of formal specifications as a testing base has many advantages. However, such specifications are not easily understood and therefore not widely used in the software industry. On the other hand, UML, a semi-formal modeling language, is becoming increasingly popular and widely accepted. In particular, UML interaction diagrams specify the dynamic, interacting behavior among the objects of an object-oriented system. If the transformation of UML interaction diagrams into Contract specifications can be automated, the TACCLE methodology can be applied directly to test object-oriented software at the cluster level. In this paper, a method to transform UML interaction diagrams into contract specifications is proposed based on the UML meta- model. A prototype has been developed.

The mutation testing focuses on the most possible mistakes of the software and so it has high ability to expose mistakes. However, at present it is still mainly used in procedure-oriented program testing. In recent years, object-oriented programming becomes more and more popular. This paper sets up the concepts for two new kinds of class level mutants for object-oriented program testing. One kind is of attribute mutants. The other is of method mutants. The formal description for the concepts is presented and the algorithms for generating attribute mutants and method mutants are proposed in this paper. A tool prototype for the algorithms is implemented and the related testing adequacy is also analyzed.

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 coherency problem affects greatly the reliability and quality of concurrent object-oriented software. Hence, Java provides the "synchronized" mechanism to help user to deal with coherency problem in multithreaded object-oriented programming. However, improper use of the "synchronized" mechanism will result in system deadlock, which also violates the requirement of software reliability and quality. In the paper, we set up a new description tool named Thread Diagram. Based on Thread Diagram, we propose a new approach to analyze potential deadlock in Java multithreaded programs with "synchronized" mechanism.

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 tester's burden, and improve the efficiency and velocity of unit test.

Testing is the most commonly used approach to the assurance of software quality and reliability. The testing of object-oriented software is much more complex than that of conventional programs. Although we proposed previously a method called TACCLE for testing object-oriented software at the class and cluster levels, it did not cover concurrent or non-deterministic situations. This paper puts forward a strategy for selecting synchronization sequences to test concurrent object-oriented software, including non-deterministic cases. It is based on OBJSA net/CLOWN specifications. Experiments have been carried out in a case study to verify the efficacy of the strategy.

Testing is one important means to improve reliability and quality of software systems. The testing for object-oriented software systems is more difficult than that of procedure-oriented programming. Based on the concept of equivalent fundamental pairs, we have proposed a new methodology for testing object-oriented software at the class level. The main results of the methodology are published in ACM Transactions on Software Engineering and Methodology (see vol.7, no.3, p.250-95, 1998). The paper refines some algorithm in the methodology. Some problem in the methodology seems undecidable at the first glance. However, the refinement in this paper shows that it is decidable.

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.

Program testing is the most widely adopted approach for assuring the quality and reliability of software systems. Despite the popularity of the objected-oriented programs, its testing is much more challenging than that of the conventional programs. We proposed previously a methodology known as TACCLE for testing object-oriented software. It has not, however, addressed the aspects of concurrency and non-determinism. In this paper, we propose a scheme for dynamically detecting and testing concurrency in object-oriented software by executing selected concurrent pairs of operations. The scheme is based on OBJSA nets and addresses concurrency and nondeterminism problems. An experimental case study is reported to show the effectiveness of the scheme in detecting deadlocks, race conditions and other coherence problems. The scheme supplements our previous static approach to detecting deadlock in Java multithreaded programs.

One of the means to enhance software reliability and quality is testing. The testing for object-oriented software is more complex and difficult than that for traditional programming. For object-oriented class-level and cluster-level testing, we proposed a significant methodology TACLLE which has been published in ACM Transactions on Software Engineering and Methodology (vol.7., no.3, p.250-95, 1998; vol.10, no.1, p.56-109, 2001). This methodology includes an important algorithm named DOE to determine whether two objects are observational equivalent or not. This paper presents the design and implementation for a new prototype of DOE using object-oriented paradigm. The new prototype is based on UML model. It is improved on the technique, and optimized in the system interface.

A dynamic approach of cluster-level testing for object oriented software system has been proposed in our previous paper published in IEEE SMC-2000. As an improvement, this paper presents a new approach for cluster-level testing. A prototype of a semi-automatic CASE tool supporting the new approach has been developed. This paper also outlines the design and implementation of the CASE tool. The analysis for message passing through data type of pointer and reference is more complicated and difficult than that through other data types. This paper also describes the details of the analysis for pointer and reference.

To ensure the reliability and quality, software systems should be safe. The software safety requires the data consistency in the software. In the multithreaded object-oriented programming, the coherency problem, also called a race condition, may destroy the data consistency. In order to overcome the coherency problem Java sets up the "synchronized" mechanism. However, improper use of the "synchronized" mechanism in Java will result in system deadlock, which also violates the requirement of software safety. We find that it is necessary to supplement a new function to the "synchronized" mechanism of Java. Another contribution in the paper is to propose a new approach for detecting system deadlock in Java multithreaded programs with the synchronized mechanism.

To enhance the reliability and quality, software systems should be tested. The object-oriented paradigm is regarded as a most promising methodology for software development. The testing of object-oriented software systems is more difficult and more complex than that for traditional programming systems. We describe an approach for object-oriented testing at the method-level. Our approach applies the data flow analysis method combined with the state transition diagram technique, access protection checking technique, and compiler technique to the object-oriented method-level tests. Based on this approach, a prototype for C++ programs has been implemented. Some experimental results on this prototype are presented. The experimental results on the prototype indicate that the approach can reveal data flow errors in C++ programs as anticipation. It supplements our previous approaches for object-oriented 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.

An authenticated encryption scheme with (t, n) shared verification was published in 1998 by Hsu and Wu under the assumption that all participant verifiers were honest. An improvement to Hsu-Wu's scheme is proposed in this paper. This improvement can prevent some verifier from cheating others. It also requires fewer transmitted messages. The security of the improved scheme is based on the factoring and discrete logarithms.

Software testing is an important technique for improving the reliability and quality of software systems. Object-oriented programming is considered to be the most promising programming methodology. We propose two approaches to generate non-equivalent ground terms as test cases. These approaches are based on the technique of fundamental equivalent pair. The basic idea of these approaches is as follows. Suppose u/sub 1//spl sim/u/sub 2/ is a fundamental equivalent pair, u/sub 2/* is the normal form of u/sub 2/. Suppose further that by changing the values of parameters of constructor contained in u/sub 2/*, or by inserting a basic constructor into u/sub 2/*, we obtain another ground term u/sub 2/', then u/sub 1/ and u/sub 2/' are nonequivalent, and can be used as a test case.

A static approach of cluster-level testing for object oriented software systems has been proposed previously. The present paper presents a dynamic approach for cluster-level testing. The approach is based on contract specification for message passing across different classes in the given cluster. The program instrumentation technique is used in this dynamic approach. A prototype of a semi-automatic CASE tool supporting this approach has been developed.

In order to improve reliability and quality, software systems should be tested. The testing of object-oriented software systems is more complex than that of traditional programming. Recently, we have proposed an approach to select a finite number of representative equivalent pairs as test cases from the infinite set of all equivalent pairs. The approach is based on the concept of equivalent fundamental pairs. We analyze the effectiveness of this approach using a class graph. A class graph can be derived from the syntax declaration of the algebraic specification for the given class under test. Using the class graph, we show that our approach omits many testing paths in the class graph but doesn't reduce the testing effect. Hence, the testing efficiency is improved greatly.

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.

Abstract 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.