Mutation from Circus specifications using mutation. This investigates Higher

 

Mutation testing and its
efficiency

 

 

Abstract

We Will Write a Custom Essay Specifically
For You For Only $13.90/page!


order now

Mutation testing,
which systematically generates a set of mutants by seeding various faults into
the base program under test, is a popular technique for evaluating the
effectiveness of a testing method. However, it normally require the large
amount of mutants and thus incurs a high cost. Firstly cost than efficiency is
the major issue in the mutation software testing. Different techniques and
approaches are used to reduce the cost and increase the efficiency. In mutation
testing, cost is reduced by reducing mutants by selecting some representative
mutants. And an approach is used for mutant’s reduction, in which two paths are
define, path-aware heuristic rule, namely module-depth and loop-depth rules, and combine them with
statement- and operator-based mutation selection to develop four mutant
reduction strategies. And also we analyses recent advances in mutation testing that
contribute to reduce the cost associated to this technique and propose to apply
them for addressing current drawbacks in Evolutionary Mutation Testing (EMT), a
genetic algorithm based technique with promising experimental results.We
investigate fault-based testing for refinement from Circus specifications using mutation. This
investigates Higher Order Mutants (HOMs). We seek the
benefits of such techniques in test-set quality assertion and fault-based
test-case selection.This presents qualitative results and bibliometric analysis
for the surveyed articles. In addition, it augments these results with
scientific findings and quantitative results from the primary literature.

Introduction

Software
testing is a process of executing a program or
application with the intent of finding the software bugs. It can also be stated
as the process of validating and verifying that a software program
or application or product. Meets the business and technical requirements that
guided its design and development. Mutation Testing 10 is a type
of software testing where we mutate (change) certain statements in
the source code and check if the test cases are able to find the
errors. It is a type of White Box Testing which is mainly used for
Unit Testing.A common way to decrease the cost of mutation testing is mutant
reduction, which selects a subset of representative mutants. It propose a new
mutant reduction approach from the perspective of program structure.1Our
approach attempts to explore path information of the program under test, and
select mutants that are as diverse as possible with respect to the paths they
cover. We define two path-aware heuristic rules, namely module-depth and
loop-depth rules, and combine them with statement- and operator-based mutation
selection to develop four mutant reduction strategies. The number of mutants significantly
affects the execution cost of mutation testing because each mutant is executed
repeatedly against at least one (potentially many) test case. Many researchers
have attempted to reduce the number of mutants without significant loss of test
effectiveness. A mutation survey paper 2 classified the approaches that use
fewer mutants into four categories: 1. mutant sampling, 2. selective mutation,
3. higher order mutation, and 4. mutant clustering. Mutant sampling uses a small percentage, say x%, of randomly
selected mutants and ignores the remaining mutants. An empirical study conducted
by Wong and Mathur showed that test sets adequate for 10% of randomly chosen
mutants were only 16% less effective than mutation analysis that used a full
set of mutants. Selective mutation uses
selective mutation operators, comprising portions of the entire mutation
operators that are nearly as effective as non-selective mutation. Higher order mutation 3 uses
higher-order mutants instead of first order mutants. The approach was
originally proposed to identify higher order mutants that denote subtle faults,
and it also suggested subsuming higher order mutant which may be preferable to
replace first order mutant. 4The work on mutation testing has
attracted a lot of attention during the last decades. Mutation testing is a
powerful mechanism to improve the quality of test suites based on the injection
of syntactic changes into the code of the original program. Several studies
have focused on reducing the high computational cost of applying this technique
and increasing its efficiency. Only some of them have tried to do it through
the application of genetic algorithms. Genetic algorithms can guide through the
generation of a reduced subset of mutants without significant loss of
information. 5We investigate
fault-based testing for refinement from Circusspecifications
using mutation. We seek the benefits of such techniques in test-set quality
assertion and fault-based test-case selection. We target results relevant not
only for Circus, but to any process
algebra for refinement that combines CSP with a data language. 6 However,
following a seminal publication in 2008, it was realized that the space of
higher-order mutants (HOMs) could be searched for useful mutants that drive
testing harder, and to reduce the overall test effort, by clever combination of
first-order mutants. 7

Literature
Review

 

Mutation testing is the
process whereby a fault is deliberately inserted into a software system, in
order to assess the quality of test data, in terms of its ability to find this
fault. Mutation testing is also used as a way to drive the test data development
process. Traditionally, faults were inserted one by one into a software system,
but more recently there has been an upsurge of interest by the area of
higher-order mutation 8, in which multiple faults are inserted into the
system at once. Originally, this was thought to be too expensive, as there was
already a concern that the size of the pool of mutants for traditional mutation
was already too large to handle. However, following a seminal publication in
2008, it was realized that the space of higher-order mutants (HOMs)
could be searched for useful mutants that drive testing harder, and to reduce
the overall test effort, by clever combination of first-order mutants 9. As a
result, many authors examined the way in which HOM testing could find
subtle hard to kill faults, capture partial fault masking, reduce equivalent
mutants problem, reduce test effort while increasing effectiveness, and capture
more realistic faults than those captured by simple insertion of first-order
mutants. Because of the upsurge of interest in the previous issues, this paper
presents the first Systematic Literature Review research specifically targeted
at a higher-order mutation. This Systematic Literature Review analyzes the
results of more than one hundred sixty research articles in this area.

Conclusion

This paper has introduced the concept of subsuming HOMs and
higher order mutation testing. We conclude that mutation testing for Circus can truly aid making test generation
from state-rich model more tractable, by focusing on particular faults.In general, our path-aware approach can reduce the
number of mutants without jeopardizing its effectiveness, and thus
significantly enhance the overall cost-effectiveness of mutation testing. Our
approach is particularly useful for the mutation testing on large-scale complex
programs that normally involve a huge amount of mutants with diverse fault
characteristics. we analyze recent advances in mutation
testing that contribute to reduce the cost associated to this technique and
propose to apply them for addressing current drawbacks in Evolutionary Mutation
Testing (EMT), a genetic algorithm based technique with promising experimental
results so far.Our approach provides an automatic testing procedure for
embedded systems developed by model-based methods, and generates test cases
efficiently using a recombination of signals. In conclusion, our proposed
method could help reduce the resources needed for test case generation from
software to hardware.In addition, it augments these results with scientific
findings and quantitative results from the primary literature. As a result of
this work, this represents an outline for many future work.

 

References:

1.       Chang-ai Sun, FeifeiXue, Huai Liu, Xiangyu Zhang, A path-aware approach to mutant
reduction in mutation testing, Information and Software Technology, 2017, 81, 65

2.      
 Y. Jia,
M. Harman, An analysis and survey of the development of mutation testing, IEEE
Transactions on Software Engineering 37 (5) (2011) 649–678.

3.      
P. Reales Mateo, M. Polo Usaola, J. L. Fernndez
Alemn, Validating second-order mutation at system level, IEEE Transactions on
Software Engineering 39 (4) (2013) 570–587.

4.       Chang-ai Sun, FeifeiXue, Huai Liu, Xiangyu Zhang, A path-aware approach to mutant
reduction in mutation testing, Information and Software Technology, 2017, 81, 65

5.       Pedro Delgado-Pérez, Inmaculada Medina-Bulo, Mercedes G. Merayo, Advances in Computational
Intelligence, 2017, 10306, 381

6.       Alex Alberto, Ana Cavalcanti, Marie-Claude Gaudel, AdenilsoSimão, Formal mutation testing for Circus, Information and Software Technology, 2017, 81, 131.

7.       Ghiduk, A. S., Girgis, M. R., , M.
H. (2017). Higher order mutation testing: A Systematic Literature Review. Computer
Science Review.

8.       Papadakis, Mike, and Nicos Malevris. “An
empirical evaluation of the first and second order mutation testing
strategies.” Software testing, verification, and validation
workshops (ICSTW), 2010 third international conference on. IEEE, 2010.

9.       Jia, Y., & Harman, M. (2008, September).
Constructing subtle faults using higher order mutation testing. In Source
Code Analysis and Manipulation, 2008 Eighth IEEE International Working
Conference on (pp. 249-258). IEEE.

10.   R.
A. DeMillo, R. J. Lipton, and F. G. Sayward. Hints on test data selection: Help
for the practicing programmer. IEEE Computer, 11(4):34–41, Apr. 1978.