Supervised By

2001

Abstract Mutation testing is a powerful, but computationally expensive, technique for unit testing software. This expense has prevented mutation from becoming widely used in practical situations, but recent engineering advances have given us techniques and algorithms for significantly reducing the cost of mutation testing.

… on Advances in System Testing and …, 2011

Mutation testing has been used along the research community as an efficient method to evaluate the process of software testing, i.e., the quality of the test suite. One major drawback is represented by the equivalent mutant problem. Through this current research we aim to come with a reliable solution to this problem and improve the available test suite pool. We do this by combining the mutation testing procedure together with a constraint satisfaction paradigm and the concept of distinguishing test cases. Mutation testing has been seen, in most of the cases, as a measure for evaluating the quality of a user's test suite. But, also mutation testing can be of great help in the test case generation process. By means of a constraint system we generate test scenarios able to distinguish between two different versions of a program. We start from the hypothesis that when our constraint system is not able to find any solution it might be the case that two equivalent mutants were encountered. The first empirical results, i.e. an increased mutation score, encourage us to further apply the strategy on medium size applications.

… Testing, Verification and …, 1999

Journal of The Brazilian Computer Society, 2002

Mutation Testing is an approach for assessing the quality of a test case suite by analyzing its ability in distinguishing the product under test from a set of alternative products, the so-called mutants. The mutants are generated from the product under test by applying a set of mutant operators, which produce products with slight syntactical differences. The mutant operators are

1994

Although mutation has been empirically found to be effective in detecting faults, it often imposes unacceptable demands on computing and human resources because of the large number of mutants that need to be compiled and executed on one or more test cases. We designed a case study to explore two alterna.tives of mutation to reduce its cost without significantly deteriorating its strength and effectiveness. The alternatives are (1) constrained abs/ror mutation which examines only the abs and ror mutants and ignores the others, and (2) randomly selected 10% mutation which examines only 10% of the randomly selected mutants of each mutation operator in Mothra. Data collected during experimentation have shown tha.t both alternatives provide a significant cost reduction in terms of the number of test cases required to satisfy an adequacy criterion and the number of mutants to be examined. Such gain is accompanied by a small strength loss in the a.bility to distinguish non-equivalent mutants and cover feasible all-uses. In terms of decreasing order of fault detection effectiveness the ranking is mutation, constrained abs/ror mutation, all-uses, and randomly selected 10% mutation. These data suggest that examining only a small percentage of the mutants may be a useful heuristic for evaluating and constructing test sets in practice.

Proceedings of the 14th International Conference on Software Technologies, 2019

Equivalent mutant problem is the most decisive problem in mutation testing and from decades efforts are doing for its betterment. Equivalent mutants are artificial seeding defects in program to certify mutation testing. Various techniques are anticipated that are efficient for finding equivalent mutant. In this survey different approaches are deliberated to analyze the performance of different approaches.Different techniques are satisfied by different parameters.

1993

Abstract Mutation analysis is a powerful technique for assessing and improving the quality of test data used to unit test software. Unfortunately, current automated mutation analysis systems suffer from severe performance problems. This paper presents a new method for performing mutation analysis that uses program schemata to encode all mutants for a program into one metaprogram, which is subsequently compiled and run at speeds substantially higher than achieved by previous interpretive systems.

Genetic and Evolutionary …, 2004

Mutation analysis is considered the best method for measuring the adequacy of test suites. However, the number of test runs required for a full mutation analysis grows faster than project size, which is not feasible for real-world software projects, which often have more than a million lines of code. It is for projects of this size, however, that developers most need a method for evaluating the efficacy of a test suite. Various strategies have been proposed to deal with the explosion of mutants. However, these strategies at best reduce the number of mutants required to a fraction of overall mutants, which still grows with program size. Running, e.g., 5% of all mutants of a 2MLOC program usually requires analyzing over 100,000 mutants. Similarly, while various approaches have been proposed to tackle equivalent mutants, none completely eliminate the problem, and the fraction of equivalent mutants remaining is hard to estimate, often requiring manual analysis of equivalence. In this paper, we provide both theoretical analysis and empirical evidence that a small constant sample of mutants yields statistically similar results to running a full mutation analysis, regardless of the size of the program or similarity between mutants. We show that a similar approach, using a constant sample of inputs can estimate the degree of stubbornness in mutants remaining to a high degree of statistical confidence, and provide a mutation analysis framework for Python that incorporates the analysis of stubbornness of mutants.