Abstract This paper proposes a model‐based regression test suite reduction method. The proposed method considers an SDL model representing the requirements of a system under test and a set of modifications on this model, applies dependence analysis to identify interaction patterns related to each type of modifications, i.e., adding, deleting, and changing transitions in the SDL model, and reduces the size of a given regression test suite by examining interaction patterns covered by each test case in the test suite. Results of empirical studies are reported. Copyright © 2009 John Wiley & Sons, Ltd.

E-commerce systems are specialized instances of distributed processing systems. The Common Object Request Broker Architecture (CORBA) provides a sophisticated infrastructure to develop and deploy distributed objects. As systems become more complex and geographically distributed, it is becoming increasingly difficult to conduct cost-effective, systematic and comprehensive testing on such systems. Using CORBA to facilitate the development and testing of e-commerce systems can greatly improve testability and directly shorten the time-to-market cycle by decreasing the test effort. This paper proposes a practical CORBA-based approach called CDATA (e-Commerce Development And Testing Approach), which supports both functional and performance testing of multiple distributed CUTs (components under test). The approach is illustrated by the implementation of an experimental e-commerce system and the corresponding testing architecture.

A trend in software development is to assemble a system from a number of components. These may be either available commercially off-the-shelf, or by the use of network-based resources. In many cases, the system is expected to function for multiple configurations of interchangeable components. The trade off that a system tester faces is the thoroughness of test component configuration coverage, versus limited resources of time and expense. This paper presents a metric that can be used to measure component interaction coverage of a set of system test configurations. It also provides a formal definition of the system test interaction problem.

Reverse engineering and design recovery are two important concepts for the evolutionary design of systems software. In particular, the reverse engineering of distributed software, such as communications systems, is a very challenging, practical problem. Most communications software is written without the use of formal methods and is often poorly documented. Consequently, to maintain or modify such software, relevant details of the original design need to be recovered from the executable software itself. This design recovery process, called reverse engineering, involves either static analysis of the code or dynamic analysis of the software behaviour based on selected execution traces. In this paper, we use the dynamic trace analysis approach. Specifically, based on execution traces as represented at selected points of observation, we generate a higher level design representation consisting of communicating finite state machines (CFSMs) corresponding to the protocol design and service constraints.

Distributed systems consist of a number of network elements that interact with each other. As the number of network elements and interchangeable components for each network element increases, the trade-off that the system tester faces is the thoroughness of test configuration coverage vs. limited resources of time and expense that are available. An approach to resolving this trade-off is to determine a set of test configurations that test each pair-wise combination of network components. This goal gives a well-defined level of test coverage, with a reduced number of system configurations. To select such a set of test configurations, we show how to apply the method of orthogonal Latin squares, from the design of balanced statistical experiments. Since the theoretical treatment assumes constraints that may not be satisfied in practice, we then show how to adapt this approach to realistic application constraints.

Eleven methods for the synthesis of communication protocols are described. Based on particular features of the synthesis process, these methods are classified and compared. In particular, it is noted that interactive methods allow flexibility in the design process; as a result, communication patterns are not prespecified but may be constructed interactively. Methods that only consider the synchronous mode of behavior of communicating entities exclude a wide range of real-life protocols. Methods that make no reference to service requirements do not guarantee the semantic correctness of the synthesized protocol and therefore require the application of a semantic verification procedure. Most methods concentrate on the synthesis of the control part of the protocol entities, which mainly consists of the exchange of synchronization messages. The data part is not adequately treated by any of the synthesis methods. Other than the exchange of synchronization messages, some methods have been extended to deal with unreliable media by synthesizing error-recovery patterns. Some new research directions for enhancing the applicability of the synthesis approach to the design of real-life protocols are obtained.>

Usefulness of a formalization of the specification of ISDN LAPD is demonstrated for designing and developing a comprehensive set of conformance tests. Since many protocol standards are specified in a natural language (i.e., English), a method for formalizing protocol specifications with a view to a number of validation activities, including conformance testing, is also presented. In particular, it is shown how to utilize the state-transition-oriented approach to automatically generate a major component of standard conformance test suites. The use of formalized specifications is also illustrated for verifying the specification by selective executions, and for validating conformance test cases against the specification.>

A standard technique for monitoring software testing activities is to instrument the module under test with counters or probes before testing begins; then, during testing, data generated by these probes can be used to identify portions of as yet unexercised code. In this paper the effect of the disciplined use of language features for explicitly delimiting control flow constructs is investigated with respect to the corresponding ease of software instrumentation. In particular, assuming all control constructs are explicitly delimited, for example, by END IF or equivalent statements, an easily programmed method is given for inserting a minimum number of probes for monitoring statement and branch execution counts without disrupting source code structure or paragraphing. The use of these probes, called statement probes, is contrasted with the use of standard (branch) probes for execution monitoring. It is observed that the results apply to well-delimited modules written in a wide variety of programming languages, in particular, Ada.

An extension of an earlier result on the computational duality of the problem of computing sets of bilinear forms by a single bilinear algorithm is given to that of computing a set of multilinear forms by a sequence of bilinear algorithms. Such problems are called piecewise bilinear computations. It is shown that piecewise bilinear computations represented by dihedral permutations of the dimensions of a multiple matrix product, for example, have exactly the same computational complexity with respect to multiplication operations as the original multiple matrix multiplication problem, and additive complexity given by the additive complexity of the original problem plus the decrease in size of the new product matrix from that of the original product matrix. This result proves that duality preserves arithmetic optimality even for algorithms developed by such local optimization techniques as dynamic programming. Finally, it is noted that since the result is constructive, it yields a method for generating equicomplex new algorithms from a given one, even if the given algorithm is nonoptimal or “approximately optimal”.

A graph-theoretic model is introduced for bilinear algorithms. This facilitates in particular the investigation of the additive complexity of matrix multiplication. The number of additions/subtractions required for each of the problems defined by symmetric permutations on the dimensions of the matrices are shown to differ conversely as the size of each product matrix. It is noted that this result holds for any system of dual problems, not only dual matrix multiplication problems. This additive symmetry is employed to obtain various results, including the fact that 15 additive operations are necessary and sufficient to multiply two $2 \times 2$ matrices by a bilinear algorithm using at most 7 multiplication operations.