Efficiency of mutation operators and selective mutation strategies: an empirical study

Mresa, Elfurjani Sassi; Bottaci, Leonardo

doi:10.1002/(sici)1099-1689(199912)9:4<205::aid-stvr186>3.0.co;2-x

Cited by 111 publications

(69 citation statements)

References 23 publications

(41 reference statements)

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…In particular, operators generating a high number of equivalent mutants are inadvisable because they represent false positives for missing test cases. Various papers have dealt with the concept of quality of mutation operator: several of them have used the mutation score (the ratio of killed mutants to non-equivalent mutants) in each particular mutation operator [27], while some others have considered new dimensions like the number and kinds of mutants generated [6,28].…”

Section: Mutation Operator Qualitymentioning

confidence: 99%

“…Another common technique for mutant reduction is selective mutation, which has been mainly applied to procedural languages like FORTRAN [27] or Ada [38]. More recently, Derezińska and Rudnik [9] studied different selective strategies regarding traditional and class-level operators for C#, finding that 93% of the original mutation score could be obtained with a reduction in the number of mutants from 18 class operators (74%) and the number of tests (14%).…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Assessment of class mutation operators for C++ with the MuCPP mutation system

Delgado‐Pérez

Medina‐Bulo

Palomo-Lozano

et al. 2017

Information and Software Technology

View full text Add to dashboard Cite

Context: Mutation testing has been mainly analyzed regarding traditional mutation operators involving structured programming constructs common in mainstream languages, but mutations at the class level have not been assessed to the same extent. This fact is noteworthy in the case of C++, despite being one of the most relevant languages including object-oriented features. Objective: This paper provides a complete evaluation of class operators for the C++ programming language. MuCPP, a new system devoted to the application of mutation testing to this language, was developed to this end. This mutation system implements class mutation operators in a robust way, dealing with the inherent complexity of the language. Method: MuCPP generates the mutants by traversing the abstract syntax tree of each translation unit with the Clang API, and stores mutants as branches in the Git version control system. The tool is able to detect duplicate mutants, avoid system headers, and drive the compilation process. Then, MuCPP is used to conduct experiments with several open-source C++ programs. Results: The improvement rules listed in this paper to reduce unproductive class mutants have a significant impact in the computational cost of the technique. We also calculate the quantity and distribution of mutants generated with class operators, which generate far fewer mutants than their traditional counterparts. Conclusions: We show that the tests accompanying these programs cannot detect faults related to particular object-oriented features of C++. In order to increase the mutation score, we create new test scenarios to kill the surviving class mutants for all the applications. The results confirm that, while traditional mutation operators are still needed, class operators can complement them and help testers further improve the test suite.

show abstract

Section: Mutation Operator Qualitymentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Assessment of class mutation operators for C++ with the MuCPP mutation system

Delgado‐Pérez

Medina‐Bulo

Palomo-Lozano

et al. 2017

Information and Software Technology

View full text Add to dashboard Cite

show abstract

“…The use of both guiding criteria, i.e., branch distance and approach level, in an additive fitness function similar to previous work [21], to fire divide-by-zero exceptions yields to a reduction of the number of fitness evaluations needed to reach a given target statement [14,12]. To the best of our knowledge, this paper presents the first use of such a fitness function to generate test data to raise divide-by-zero exceptions.…”

Section: Introductionmentioning

confidence: 91%

“…Consequently, we follow the work by Tracey et al [18] on the generation of test data to raise exceptions and by others [14,21,3] on branch coverage criteria to propose a novel approach to generate test data for raising divide-by-zero exceptions for integers. In [18], the authors proposed to transform a target system so that the problem of generating test data to raise some exceptions becomes equivalent to a problem of branch coverage.…”

Section: Introductionmentioning

confidence: 99%

Divide-by-Zero Exception Raising via Branch Coverage

Bhattacharya

Sakti

Antoniol

et al. 2011

Search Based Software Engineering

View full text Add to dashboard Cite

Abstract. In this paper, we discuss how a search-based branch coverage approach can be used to design an effective test data generation approach, specifically targeting divide-by-zero exceptions. We first propose a novel testability transformation combining approach level and branch distance. We then use different search strategies, i.e., hill climbing, simulated annealing, and genetic algorithm, to evaluate the performance of the novel testability transformation on a small synthetic example as well as on methods known to throw divide-by-zero exceptions, extracted from real world systems, namely Eclipse and Android. Finally, we also describe how the test data generation for divide-by-zero exceptions can be formulated as a constraint programming problem and compare the resolution of this problem with a genetic algorithm in terms of execution time. We thus report evidence that genetic algorithm using our novel testability transformation out-performs hill climbing and simulated annealing and a previous approach (in terms of numbers of fitness evaluation) but is out-performed by constraint programming (in terms of execution time).

show abstract

“…Regarding mutant generation, most works try to decrease the number of mutants generated, with different studies existing for selecting the most meaningful operators [5,6], as well as techniques for generating the mutants more quickly [7]. Regarding test execution, several authors have proposed the use weak mutation [8,9], prioritization of the functions of the program under test [10] or the use of n-order mutants [11].…”

Section: Fig 2 Mutation Scorementioning

confidence: 99%