Search

In order to ensure reliability and quality, software systems must be tested. The testing includes generating test cases, executing test cases on the program, and determining whether the results of execution conform to requirements. The last is called the oracle problem. The oracle problem is important but difficult as the program yields the results in a way which may depend on some representation choices and makes the comparison with the specified results difficult. The class level testing is considered to be basic in object-oriented software testing. Breu et al. (1998) proposed an algebraic design methodology for object-based systems. We found that this design methodology can be used to deal with the oracle problem in object-oriented class level testing. Given an algebraic specification for a class, suppose the equivalent ground terms u/sub 1//spl sim/u/sub 2/ are selected as a test case. Using the representation function rep() provided by Breu's algebraic design methodology, u/sub 1/ and u/sub 2/ can be mapped to method sequences s/sub 1/ and s/sub 2/ in the implementation, respectively. Executing s/sub 1/ and s/sub 2/ in the implementation, we obtain accordingly two objects O/sub 1/ and O/sub 2/ of the given class.

Client-server systems are being widely used for transaction or distributed processing. Such systems contain three application components: interface-representation, business-process, and data-management. In a two-level client-server system, most interface-representations reside generally in the client, most data-management is usually arranged in the server. However, business-processes should be partitioned into two parts, which are allocated to client and server, respectively. The partition is important in the software design phase since it greatly affects system performance, especially the balance of task loading and the data traffic through the net connecting client and server. The partition comprises three levels: functionality level, task level, and program module level. We consider the functionality partition only, since it is at the top level, and affects system performance greatly. We apply a dataflow diagram (DFD) to specify the functions of the system under design. By using DFD, we create a discrete model and an algorithm for the functionality partition.

One of the means to enhance reliability and quality of software systems is testing. Object-oriented methodology makes resulting software systems more reliable, maintainable and reusable. However, it also renders the testing more complex and difficult. There are various sequences and combinations to execute the methods in a class or across different classes. This character leads us to select sequences of operations (namely ground terms), rather than individual operations, as test cases in object-oriented class level testing. The pairs of equivalent ground terms can be derived as test cases from a given algebraic specification for a class. If two ground terms are equivalent, but their implemented sequences produce observationally non-equivalent objects, then there is an error in the implementation. However, the set of all equivalent pairs is generally infinite. How do we select a finite number of them? Recently, we have proposed an approach to deal with this problem. In our approach, a fundamental pair is defined as a pair of equivalent terms produced by substituting 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.

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.

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.