Article Preview
Top1. Introduction
Evaluation of software quality is a fundamental research topic in software engineering areas. The exactness of the software application is analyzed using software testing theory (Jatana and Suri, 2020). Software testing acts as a major part of evaluating the software quality or the programs under test (Naeem, et al., 2019). Software testing includes product execution or software application execution along with the group of test cases with the objective of identifying the troubles. The debugging procedure is performed when the testing process shows output variations, which are detected as bugs (Jamil, et al., 2016; Kasurinen, 2010). The test cases are the input sets or the execution preconditions implemented to check whether the particular condition is catered or not (Jovanović, 2006). The compilation of test cases accomplished in satisfying the testing conditions are named as the efficient test suite (Chen and Lau, 1998; Jatana and Suri, 2020). Software testers utilize test suites for finding faults in the software when unexpected activity is identified. Hence, the capability of the software testing for identifying the blunders is extremely corresponded to test suites standard. For measuring the quality of the test suites, mutation testing detects whether the test suite is appropriate for identifying the faults by creating syntactic variations in the source code (Jia and Harman, 2010; Naeem, et al., 2019). On the other hand, the code average is also measured to be an efficient technique by analyzing the source code proportion executed by the inputs of the test suite. Nevertheless, the coverage of code alone failed to expose the efficiency in the test suites (Inozemtseva and Holmes, 2014; Naeem, et al., 2019; Kirmani and Wahid, 2015).
Mutation testing is a fault-enabled method that supports producing efficient test cases (Clegg, et al., 2017; Chen and Zhang, 2018; Mao, et al., 2019; Bashir and Nadeem, 2017). It is an efficient fault-driven approach for testing test suite quality by impulsing syntactic blunders. Besides, mutation testing finds whether the test suite is much enough to determine these syntactic faults or not (Jia and Harman, 2010; Singh, et al., 2013; Naeem, et al., 2020). In the process of mutation testing, a large amount of blunder programs, like mutants, which are produced from the real program through the mutant operators. The execution faulty programs are executed besides test suites. If any blunders are founded by the test suite, then the mutants are categorized as killed. Besides, if an outcome generated by the test suite is the same as the real programs, the mutants are regarded as alive. A capability of test suites is computed by the Mutation Score Indicator (MSI), which is a percent of the total number of the killed mutants to overall mutants. The scores produced by mutation testing can assist software testers in locating weaknesses in test suites and also in devising original test cases. With the exclusion of quality assessment of the test suites, mutation testing has also demonstrated its importance in simulating the practical faults (Lou, et al.,2015), faults localization (Moon, et al., 2014), and model transformation testing (Aranega, et al., 2010; Naeem, et al., 2019; Dineva and Atanasova, 2022; Kulkarni, 2022). Moreover, the mutant operators can be devised with respect to the defect model in such a way that the mutant operators generate instances of the recognized flaws or by mutating syntactic workings of the programming language (Wang, et al., 2019; Papadakis, et al., 2019). The latter produces an extremely huge amount of the mutants, thereby making the energy-aware mutation testing impossible as the energy testing should be done on the real devices for achieving appropriate measurements of battery discharge (Jabbarvand and Malek, 2017).