Key Problem of Component-Based Software Development

2014 ◽  
Vol 687-691 ◽  
pp. 1896-1899
Author(s):  
Ya Ping Cui
Keyword(s):  
Genetic Algorithm ◽  
Fitness Function ◽  
Dynamic Test ◽  
Test Point ◽  
Test Case ◽  
Test Cases ◽  
Data Generation ◽  
Rate Of Increase ◽  
Coding Method ◽  
Path Coverage

In order to improve the component dynamic test efficiency, this paper proposes a keating component built-in test case generation method of genetic algorithm and designs the chromosome coding method. The test point and keating component facet description of dynamic test data generation method. Mass in order to improve the generation of test cases and add Yang the convergence speed of genetic algorithm. We improve the algorithm of the method for calculating the fitness function and fitness function not only consider the case of path coverage, but also considers the path coverage rate of increase, thus effectively improved the path coverage and reduce the Yang cases produce cost.

A Analysis and Research on the Methods of Object Oriented Software Testing

2013 ◽  
Vol 709 ◽  
pp. 616-619
Author(s):  
Jing Chen
Keyword(s):  
Genetic Algorithm ◽  
Genetic Algorithms ◽  
Test Data ◽  
Object Oriented ◽  
Automatic Generation ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Path Coverage ◽  
Parameter Values

This paper proposes a genetic algorithm-based method to generate test cases. This method provides information for test case generation using state machine diagrams. Its feature is realizing automation through fewer generated test cases. In terms of automatic generation of test data based on path coverage, the goal is to build a function that can excellently assess the generated test data and guide the genetic algorithms to find the targeting parameter values.

scholarly journals Automated Test Data Generation Based on a Genetic Algorithm with Maximum Code Coverage and Population Diversity

2021 ◽  
Vol 11 (10) ◽  
pp. 4673
Author(s):  
Tatiana Avdeenko ◽  
Konstantin Serdyukov
Keyword(s):  
Test Data ◽  
Fitness Function ◽  
Population Diversity ◽  
Test Case ◽  
Test Cases ◽  
Data Generation ◽  
Intelligent Support ◽  
Automated Generation ◽  
Code Coverage ◽  
Automated Test Data Generation

In the present paper, we investigate an approach to intelligent support of the software white-box testing process based on an evolutionary paradigm. As a part of this approach, we solve the urgent problem of automated generation of the optimal set of test data that provides maximum statement coverage of the code when it is used in the testing process. We propose the formulation of a fitness function containing two terms, and, accordingly, two versions for implementing genetic algorithms (GA). The first term of the fitness function is responsible for the complexity of the code statements executed on the path generated by the current individual test case (current set of statements). The second term formulates the maximum possible difference between the current set of statements and the set of statements covered by the remaining test cases in the population. Using only the first term does not make it possible to obtain 100 percent statement coverage by generated test cases in one population, and therefore implies repeated launch of the GA with changed weights of the code statements which requires recompiling the code under the test. By using both terms of the proposed fitness function, we obtain maximum statement coverage and population diversity in one launch of the GA. Optimal relation between the two terms of fitness function was obtained for two very different programs under testing.

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.

scholarly journals Performance of Enhanced Multiple-Searching Genetic Algorithm for Test Case Generation in Software Testing

Mathematics ◽  
2021 ◽  
Vol 9 (15) ◽  
pp. 1779
Author(s):  
Wanida Khamprapai ◽  
Cheng-Fa Tsai ◽  
Paohsi Wang ◽  
Chi-En Tsai
Keyword(s):  
Genetic Algorithm ◽  
Software Testing ◽  
Random Search ◽  
Automatic Generation ◽  
Superior Performance ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Network Systems ◽  
Routing Problem

Test case generation is an important process in software testing. However, manual generation of test cases is a time-consuming process. Automation can considerably reduce the time required to create adequate test cases for software testing. Genetic algorithms (GAs) are considered to be effective in this regard. The multiple-searching genetic algorithm (MSGA) uses a modified version of the GA to solve the multicast routing problem in network systems. MSGA can be improved to make it suitable for generating test cases. In this paper, a new algorithm called the enhanced multiple-searching genetic algorithm (EMSGA), which involves a few additional processes for selecting the best chromosomes in the GA process, is proposed. The performance of EMSGA was evaluated through comparison with seven different search-based techniques, including random search. All algorithms were implemented in EvoSuite, which is a tool for automatic generation of test cases. The experimental results showed that EMSGA increased the efficiency of testing when compared with conventional algorithms and could detect more faults. Because of its superior performance compared with that of existing algorithms, EMSGA can enable seamless automation of software testing, thereby facilitating the development of different software packages.

scholarly journals Bi-Objective Constraint and Hybrid Optimizer for the Test Case Prioritization

2019 ◽  
Vol 8 (6) ◽  
pp. 3436-3448
Keyword(s):  
Taylor Series ◽  
Optimization Algorithm ◽  
Fitness Function ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Optimal Test ◽  
Average Percentage ◽  
Branch Coverage

Regression testing is performed to make conformity that any changes in software program do not disturb the existing characteristics of the software. As the software improves, the test case tends to grow in size that makes it very costly to be executed, and thus the test cases are needed to be prioritized to select the effective test cases for software testing. In this paper, a test case prioritization technique in regression testing is proposed using a novel optimization algorithm known as Taylor series-based Jaya Optimization Algorithm (Taylor-JOA), which is the integration of Taylor series in Jaya Optimization Algorithm (JOA). The optimal test cases are selected based on the fitness function, modelled depending on the constraints, namely fault detection and branch coverage. The experimentation of the proposed Taylor-JOA is performed with the consideration of the evaluation metrics, namely Average Percentage of Fault Detected (APFD) and the Average Percentage of Branch Coverage (APBC). The APFD and the APBC of the proposed Taylor-JOA is 0.995, and 0.9917, respectively, which is high as compared to the existing methods that show the effectiveness of the proposed Taylor-JOA in the task of test case prioritization

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.

Comparison of Multi-Objective Evolutionary Algorithms to Prioritize Regression Test Cases

2021 ◽  
Vol 9 (12) ◽  
pp. 1445-1454
Keyword(s):  
Fault Detection ◽  
Evolutionary Algorithms ◽  
Fitness Function ◽  
Optimal Solution ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Nsga Ii ◽  
Multi Objective ◽  
Regression Test

Regression testing is one of the most critical testing activities among software product verification activities. Nevertheless, resources and time constraints could inhibit the execution of a full regression test suite, hence leaving us in confusion on what test cases to run to preserve the high quality of software products. Different techniques can be applied to prioritize test cases in resource-constrained environments, such as manual selection, automated selection, or hybrid approaches. Different Multi-Objective Evolutionary Algorithms (MOEAs) have been used in this domain to find an optimal solution to minimize the cost of executing a regression test suite while obtaining maximum fault detection coverage as if the entire test suite was executed. MOEAs achieve this by selecting set of test cases and determining the order of their execution. In this paper, three Multi Objective Evolutionary Algorithms, namely, NSGA-II, IBEA and MoCell are used to solve test case prioritization problems using the fault detection rate and branch coverage of each test case. The paper intends to find out what’s the most effective algorithm to be used in test cases prioritization problems, and which algorithm is the most efficient one, and finally we examined if changing the fitness function would impose a change in results. Our experiment revealed that NSGA-II is the most effective and efficient MOEA; moreover, we found that changing the fitness function caused a significant reduction in evolution time, although it did not affect the coverage metric.

scholarly journals TEST CASE PRIORTIZATION USING GENETIC ALGORITHM

2014 ◽  
pp. 151-154
Author(s):  
RUCHIKA MALHOTRA ◽  
ABHISHEK BHARADWAJ
Keyword(s):  
Genetic Algorithm ◽  
Software Development ◽  
Software Testing ◽  
Major Part ◽  
Test Case ◽  
Test Cases ◽  
Development Lifecycle ◽  
Software Development Lifecycle ◽  
The One

Software is built by human so it cannot be perfect. So in order to make sure that developed software does not do any unintended thing we have to test every software before launching it in the operational world. Software testing is the major part of software development lifecycle. Testing involves identifying the test cases which can find the errors in the program. Exhaustive testing is not a good idea to follow. It is very difficult and time consuming to perform. In this paper a technique has been proposed to do prioritize test cases according to their capability of finding errors. One which is more likely to find the errors has been assigned a higher priority and the one which is less likely to find the errors in the program has been assigned low priority. It is recommended to execute the test cases according their priority to find the errors.

scholarly journals Test Case Generation for UML Behavioral Diagram by Traversal Algorithm

2019 ◽  
Vol 8 (10) ◽  
pp. 3262-3266
Keyword(s):  
Accurate Result ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Sequence Diagrams ◽  
Research Focus ◽  
Activity Diagram ◽  
Path Coverage ◽  
The Comparative Study ◽  
Traversal Algorithm

Software testing play crucial role in the software development as it consumes lot of time and resources. However testing process needs to be more efficiently done because overall software quality relies upon good testing approach. The present research focus on generation of test cases from UML diagrams. The combination graph is made by using activity and sequence diagrams. These diagrams proves to be more efficient as activity diagram gives the dynamic behavior of the model and sequence diagram is used to understand detailed functionality of the system. In this paper, a combined approach using Breadth first and depth first search is proposed which will generate expected test cases. The comparative study is done for test case generation using BFS and DFS algorithm and the result proves that the DFS traversal algorithm provides more accurate result for path coverage.

scholarly journals K-Step Crossover Method based on Genetic Algorithm for Test Suite Prioritization in Regression Testing

2021 ◽  
Vol 27 (2) ◽  
pp. 170-189
Author(s):  
P. K. Gupta
Keyword(s):  
Genetic Algorithm ◽  
Regression Testing ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Average Percentage ◽  
Code Coverage ◽  
Test Case Selection ◽  
Case Selection

Software is an integration of numerous programming modules  (e.g., functions, procedures, legacy system, reusable components, etc.) tested and combined to build the entire module. However, some undesired faults may occur due to a change in modules while performing validation and verification. Retesting of entire software is a costly affair in terms of money and time. Therefore, to avoid retesting of entire software, regression testing is performed. In regression testing, an earlier created test suite is used to retest the software system's modified module. Regression Testing works in three manners; minimizing test cases, selecting test cases, and prioritizing test cases. In this paper, a two-phase algorithm has been proposed that considers test case selection and test case prioritization technique for performing regression testing on several modules ranging from a smaller line of codes to huge line codes of procedural language. A textual based differencing algorithm has been implemented for test case selection. Program statements modified between two modules are used for textual differencing and utilized to identify test cases that affect modified program statements. In the next step, test case prioritization is implemented by applying the Genetic Algorithm for code/condition coverage. Genetic operators: Crossover and Mutation have been applied over the initial population (i.e. test cases), taking code/condition coverage as fitness criterion to provide a prioritized test suite. Prioritization algorithm can be applied over both original and reduced test suite depending upon the test suite's size or the need for accuracy. In the obtained results, the efficiency of the prioritization algorithms has been analyzed by the Average Percentage of Code Coverage (APCC) and Average Percentage of Code Coverage with cost (APCCc). A comparison of the proposed approach is also done with the previously proposed methods and it is observed that APCC & APCCc values achieve higher percentage values faster in the case of the prioritized test suite in contrast to the non-prioritized test suite.

Sign in / Sign up

Export Citation Format

Share Document