Several module and class testing techniques have been applied to object‐oriented (OO) programs, but researchers have only recently begun developing test criteria that evaluate the use of key OO features such as inheritance, polymorphism, and encapsulation. Mutation testing is a powerful testing technique for generating software tests and evaluating the quality of software. However, the cost of mutation testing has traditionally been so high that it cannot be applied without full automated tool support. This paper presents a method to reduce the execution cost of mutation testing for OO programs by using two key technologies, mutant schemata generation (MSG) and bytecode translation. This method adapts the existing MSG method for mutants that change the program behaviour and uses bytecode translation for mutants that change the program structure. A key advantage is in performance: only two compilations are required and both the compilation and execution time for each is greatly reduced. A mutation tool based on the MSG/bytecode translation method has been built and used to measure the speedup over the separate compilation approach. Experimental results show that the MSG/bytecode translation method is about five times faster than separate compilation. Copyright © 2004 John Wiley & Sons, Ltd.

In object-oriented systems, cohesion refers to the degree of the relatedness of the members in a class and strong cohesion has been recognized as a highly desirable property of classes. We note that the existing cohesion measures do not take i n to account s o m e c haracteristics of classes, and thus often fail to properly re ect the cohesiveness of classes. To c o p e w i t h such a problem, we propose a new cohesion measure where the characteristics of classes are incorporated. Our cohesion measure takes into account t h e m e m bers that have actually impact on the cohesiveness of a class, and is de ned in terms of the degree of the connectivity among those members.We develop a cohesion measurement tool for C++ programs and perform a case study on a w ell-known class library in order to demonstrate the e ectiveness of our new measure. By performing principal component analysis, we also demonstrate that our measure captures a new aspect of class properties which is not captured by the existing cohesion measures.

Slicing techniques can provide solutions to many software engineering problems such as testing, program understanding and extraction of a reusable component. However, current slicing criteria and the corresponding techniques might obtain slices that contain unnecessary statements in some situations. In this paper, we propose a new slicing technique that takes the specification of the slice into account. The information present in the specification helps to produce more precise slices by removing statements that are not relevant to the specification for the slice. Our technique is based on the weakest precondition and strongest postcondition. We present an example of applying the proposed technique in extracting a reusable component from an existing program.

Refactoring is a widely accepted technique to improve the software quality by restructuring its design without changing its behavior. In general, a sequence of refactorings needs to be applied until the quality of the code is improved satisfactorily. In this case, the final design after refactoring can vary with the application order of refactorings, thereby producing different quality improvements. Therefore, it is necessary to determine a proper refactoring schedule to obtain as many benefits as possible. However, there is little research on the problem of generating appropriate schedules to maximize quality improvement. In this paper, we propose an approach to automatically determine an appropriate schedule to maximize quality improvement through refactoring. We first detect code clones that are suitable for refactoring and generate the most beneficial refactoring schedule to remove them. It is straightforward to select the best from the exhaustively enumerated schedules. However, such a technique becomes NP‐hard, as the number of available refactorings increases. We apply a genetic algorithm (GA) to generate the best refactoring schedule within a reasonable time to cope with this problem. We compare the GA‐based approach with manual scheduling, greedy heuristic‐based, and exhaustive approaches for four open systems. The results show that the proposed GA‐based approach generates more beneficial schedules than the others. Copyright © 2010 John Wiley & Sons, Ltd.

Although mutation testing is potentially powerful, it is a computationally expensive testing method. To investigate how we can reduce the cost of object‐oriented mutation testing, we have conducted empirical studies on class mutation operators. We applied class mutation operators to 866 classes contained in six open‐source programs. An analysis of the number and the distribution of class mutants generated and preliminary data on the effectiveness of some operators are provided. Our study shows that the overall number of class mutants is smaller than for traditional mutants, which offers the possibility that class mutation can be made practically affordable.