scholarly journals On the Effectiveness of Using Elitist Genetic Algorithm in Mutation Testing

Symmetry ◽  
2019 ◽  
Vol 11 (9) ◽  
pp. 1145 ◽  
Author(s):  
Shweta Rani ◽  
Bharti Suri ◽  
Rinkaj Goyal
Keyword(s):  
Genetic Algorithm ◽  
Test Data ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Test Data Generation ◽  
Data Generation ◽  
Test Execution ◽  
Mutation Strategy

Manual test case generation is an exhaustive and time-consuming process. However, automated test data generation may reduce the efforts and assist in creating an adequate test suite embracing predefined goals. The quality of a test suite depends on its fault-finding behavior. Mutants have been widely accepted for simulating the artificial faults that behave similarly to realistic ones for test data generation. In prior studies, the use of search-based techniques has been extensively reported to enhance the quality of test suites. Symmetry, however, can have a detrimental impact on the dynamics of a search-based algorithm, whose performance strongly depends on breaking the “symmetry” of search space by the evolving population. This study implements an elitist Genetic Algorithm (GA) with an improved fitness function to expose maximum faults while also minimizing the cost of testing by generating less complex and asymmetric test cases. It uses the selective mutation strategy to create low-cost artificial faults that result in a lesser number of redundant and equivalent mutants. For evolution, reproduction operator selection is repeatedly guided by the traces of test execution and mutant detection that decides whether to diversify or intensify the previous population of test cases. An iterative elimination of redundant test cases further minimizes the size of the test suite. This study uses 14 Java programs of significant sizes to validate the efficacy of the proposed approach in comparison to Initial Random tests and a widely used evolutionary framework in academia, namely Evosuite. Empirically, our approach is found to be more stable with significant improvement in the test case efficiency of the optimized test suite.

TEST DATA GENERATION FOR SOFTWARE TESTING BASED ON QUANTUM-INSPIRED GENETIC ALGORITHM

2013 ◽  
Vol 12 (01) ◽  
pp. 1350004 ◽  
Author(s):  
CHENGYING MAO ◽  
XINXIN YU
Keyword(s):  
Genetic Algorithm ◽  
Software Testing ◽  
Test Data ◽  
Optimal Solution ◽  
Search Space ◽  
Structural Testing ◽  
Test Data Generation ◽  
Data Generation ◽  
Quantum Bit

The quality of test data has an important impact on the effect of software testing, so test data generation has always been a key task for finding the potential faults in program code. In structural testing, the primary goal is to cover some kinds of structure elements with some specific inputs. Search-based test data generation provides a rational way to handle this difficult problem. In the past, some well-known meta-heuristic search algorithms have been successfully utilized to solve this issue. In this paper, we introduce a variant of genetic algorithm (GA), called quantum-inspired genetic algorithm (QIGA), to generate the test data with stronger coverage ability. In this new algorithm, the traditional binary bit is replaced by a quantum bit (Q-bit) to enlarge the search space so as to avoid falling into local optimal solution. On the other hand, some other strategies such as quantum rotation gate and catastrophe operation are also used to improve algorithm efficiency and quality of test data. In addition, experimental analysis on eight real-world programs is performed to validate the effectiveness of our method. The results show that QIGA-based method can generate test data with higher coverage in much smaller convergence generations than GA-based method. More importantly, our proposed method is more robust for algorithm parameter change.

scholarly journals A Sound Assessment of Test Suite Minimization Techniques

2018 ◽  
Vol 7 (2) ◽  
pp. 87-91
Author(s):  
Fayaz Ahmad Khan
Keyword(s):  
Software Development ◽  
Test Data ◽  
Comprehensive Analysis ◽  
Test Suite ◽  
Test Cases ◽  
Test Data Generation ◽  
Data Generation ◽  
Before And After ◽  
New Ideas ◽  
Automatic Test Data Generation

During software development, testing and re-testing occurs frequently to ensure that the software is working correctly before and after modifications. To carry out an effective testing process a test suite is created and executed to detect the faults in the existing code as well as in the modified code. The manual approach of test suite creation and execution is time consuming and labour intensive task as compared to automatically generated test data or test suite. The automatic test data generation is supposed to be an effective way, but a lot of redundant test cases are generated that increase the time, effort and cost of testing. Therefore, test suite minimization techniques are used to further minimize or reduce the number of test cases by selecting a subset from an initially random and large test suite to test the code before as well as after modification. In this study, a comprehensive analysis of the different test suite minimization techniques is presented in order to extend the existing studies and to propose new ideas in this direction.

scholarly journals Mutated Specification-Based Test Data Generation with a Genetic Algorithm

Mathematics ◽  
2021 ◽  
Vol 9 (4) ◽  
pp. 331
Author(s):  
Rong Wang ◽  
Yuji Sato ◽  
Shaoying Liu
Keyword(s):  
Genetic Algorithm ◽  
Test Data ◽  
Test Cases ◽  
Formal Specifications ◽  
Data Generation ◽  
Testing Methods ◽  
Functional Changes ◽  
Target Program ◽  
Generate Test Data

Specification-based testing methods generate test data without the knowledge of the structure of the program. However, the quality of these test data are not well ensured to detect bugs when non-functional changes are introduced to the program. To generate test data effectively, we propose a new method that combines formal specifications with the genetic algorithm (GA). In this method, formal specifications are reformed by GA in order to be used to generate input values that can kill as many mutants of the target program as possible. Two classic examples are presented to demonstrate how the method works. The result shows that the proposed method can help effectively generate test cases to kill the program mutants, which contributes to the further maintenance of software.

scholarly journals Test Suite Minimization using Hybrid Algorithm for GA generated Test Cases

2013 ◽  
Vol 6 (1) ◽  
pp. 279-286 ◽  
Author(s):  
Mrs. P Maragathavalli ◽  
S. Kanmani
Keyword(s):  
Test Data ◽  
Execution Time ◽  
Hybrid Algorithm ◽  
Mutant Gene ◽  
Test Suite ◽  
Test Cases ◽  
Testing Time ◽  
Test Data Generation ◽  
Data Generation ◽  
Minimization Procedure

Software testing and retesting occurs continuously during the software development lifecycle to detect errors as early as possible. As the software evolves the size of test suites also grows. When the no of test cases generated are more, obviously size of the test suite will also be more.  So the testing time is to be minimized by reducing the execution time of the algorithm used for test data generation and also by introducing minimization procedure for test suite reduction. Due to limited resources and timing constraints for testing, test suite minimization techniques are needed to eliminate redundant test cases as possible. By considering multiple objectives rather than the coverage alone, the test cases are being generated which satisfies the testing requirements. Most of the existing techniques are code-based. In this article we present an approach by modifying an existing heuristic for test suite minimization.  Genetic algorithm has been used for random test data generation and the output of GA is given to the minimization procedure for reducing the total no of generated test cases, collectively named as Hybrid Algorithm (HA). The results are satisfactory and show significant improvements in reducing test suite size with minimum execution time. Experiments have been done for simple to medium complexity java programs taken from SIR and execution time is reduced to 5,685ms for a test set. The results are compared with existing method Mutant Gene Algorithm and size of test suite is minimized upto 13.6% using Hybrid Algorithm.

scholarly journals A Review of Test Data Generation and Adequacy Criteria

2017 ◽  
Vol 7 (2) ◽  
pp. 35
Author(s):  
Sheetal Rajput
Keyword(s):  
Software Testing ◽  
Test Data ◽  
Test Suite ◽  
Test Cases ◽  
Test Data Generation ◽  
Data Generation ◽  
Design Rules ◽  
Good Design ◽  
Test Suites

<div><p><em>In the software testing a real way of measuring effective testing is that the system passes an adequate suite of test cases, and then it must be correct or dependable. But that’s impossible because the adequacy of test suites is provably undecidable. So we’ll have to settle adequacy Design rules to highlight inadequacy of test suites. Design rules do not guarantee good designs. Good design depends on talented, creative, disciplined designers and that can be the best test suite set to fulfill adequacy criteria</em><em>.</em></p></div>

scholarly journals Software Test Data Generation based on Path Testing using Genetic Algorithms

2020 ◽  
Vol 8 (6) ◽  
pp. 4466-4473
Keyword(s):  
Genetic Algorithms ◽  
Test Data ◽  
Iterative Algorithms ◽  
Continuous Functions ◽  
Software Test ◽  
Test Cases ◽  
Test Data Generation ◽  
Data Generation ◽  
Optimal Solutions ◽  
Automated Test

Test data generation is the task of constructing test cases for predicting the acceptability of novel or updated software. Test data could be the original test suite taken from previous run or imitation data generated afresh specifically for this purpose. The simplest way of generating test data is done randomly but such test cases may not be competent enough in detecting all defects and bugs. In contrast, test cases can also be generated automatically and this has a number of advantages over the conventional manual method. Genetic Algorithms, one of the automation techniques, are iterative algorithms and apply basic operations repeatedly in greed for optimal solutions or in this case, test data. By finding out the most error-prone path using such test cases one can reduce the software development cost and improve the testing efficiency. During the evolution process such algorithms pass on the better traits to the next generations and when applied to generations of software test data they produce test cases that are closer to optimal solutions. Most of the automated test data generators developed so far work well only for continuous functions. In this study, we have used Genetic Algorithms to develop a tool and named it TG-GA (Test Data Generation using Genetic Algorithms) that searches for test data in a discontinuous space. The goal of the work is to analyze the effectiveness of Genetic Algorithms in automated test data generation and to compare its performance over random sampling particularly for discontinuous spaces.

Proposal of Iterative Genetic Algorithm for Test Suite Generation

2021 ◽  
Vol 12 (1) ◽  
pp. 111-130
Author(s):  
Ankita Bansal ◽  
Abha Jain ◽  
Abhijeet Anand ◽  
Swatantra Annk
Keyword(s):  
Genetic Algorithm ◽  
Execution Time ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Computation Complexity ◽  
Test Suite Generation ◽  
Adaptive Nature ◽  
Efficiency And Reliability

Huge and reputed software industries are expected to deliver quality products. However, industry suffers from a loss of approximately $500 billion due to shoddy software quality. The quality of the product in terms of its accuracy, efficiency, and reliability can be revamped through testing by focusing attention on testing the product through effective test case generation and prioritization. The authors have proposed a test-case generation technique based on iterative listener genetic algorithm that generates test cases automatically. The proposed technique uses its adaptive nature and solves the issues like redundant test cases, inefficient test coverage percentage, high execution time, and increased computation complexity by maintaining the diversity of the population which will decrease the redundancy in test cases. The performance of the technique is compared with four existing test-case generation algorithms in terms of computational complexity, execution time, coverage, and it is observed that the proposed technique outperformed.

Sign in / Sign up

Export Citation Format

Share Document