Test Case Optimization and Prioritization Based on Multi-objective Genetic Algorithm

Web application testing based on user session reduces artificial efforts while designing and generating test cases. It attracts more and more researchers and forms a hot spot of web application testing. Reduction, prioritization, and selection of test cases are widely used for the testing based on user session. In this paper, web application test cases optimization based on clustering is researched, and a novel method named USCHC (User Sessions Clustering based on Hierarchical Clustering algorithm for test cases optimization) is proposed. This method firstly gives the function to calculate the distance between the user sessions, and then employs the bottom-up agglutinate hierarchical clustering algorithm to cluster the initial testing cases and produces different kinds of test suites. From the clustered test suites, representative test cases are selected to replace the original test cases in each kind of test suites to test the functionality of web applications. The experiments show that the number of test cases is reduced through USCHC while the testing efficiency is improved.

This paper proposes a novel test case prioritization technique, namely multi-objective crow search and fruitfly optimization (MOCSFO) for test case prioritization. The proposed MOCSFO is designed by integrating crow search algorithm (CSA) and chaotic fruitfly optimization algorithm (CFOA). The optimal test cases are selected based on newly modelled fitness function, which consist of two parameters, namely average percentage of combinatorial coverage (APCC) and normalized average of the percentage of faults detected (NAPFD). The test case to be selected is decided using a searching criterion or fitness based on sequential weighed coverage size. Accordingly, the effective searching criterion is formulated to determine the optimal test cases based on the constraints. The experimentation of the proposed MOCSFO method is performed by considering the performance metrics, like NAPFD and APCC. The proposed MOCSFO outperformed the existing methods with enhanced NAPFD of 0.7, and APCC of 0.837.

Software testing is a very important and crucial phase of software development life cycle. In order to develop good quality software, the effectiveness of the software has been tested. Test cases and test suites are prepared for testing, and it should be done in minimum time for which test case prioritization and optimization techniques are required. The main aim of test case prioritization is to test software in minimum time and with maximum efficiency, so for this there are many techniques, and to develop a new or better technique, existing techniques should be known. This paper presents a review on the techniques of test case prioritization and optimization. This paper also provides analysis of the literature available for the same.

Unit testing has a significant role in software development and its impacts depend on the quality of test cases and test data used. To reduce time and effort, unit test generator systems can help automatically generate test cases and test data. However, there is currently no unit test generator for Kotlin programming language even though this language is popularly used for android application developments. In this study, we propose and develop a test generator system that utilizes genetic algorithm (GA) and ANTLR4 parser. GA is used to obtain the most optimal test cases and data for a given Kotlin code. ANTLR4 parser is used to optimize the mutation process in GA so that the mutation process is not totally random. Our model results showed that the average value of code coverage in generated unit tests against instruction coverage is 95.64%, with branch coverage of 76.19% and line coverage of 96.87%. In addition, only two out of eight generated classes produced duplicate test cases with a maximum of one duplication in each class. Therefore, it can be concluded that our optimization with GA on the unit test generator is able to produce unit tests with high code coverage and low duplication.

Every application software that we propose to develop can be thought of a group or collection of related requirements specified by the user and these requirements are the foundation from which the quality of the software is measured. Until now there is no concrete measurement methodology for measuring the requirements of any application software. A new value driven quantitative measurement approach is presented in this research work. These values associated with each of the requirements are collectively called as Requirement Factor Values (RFV). This new measurement method uses the Goal-Question-Metric (GQM) approach and it is one of the most powerful approaches available for metrics measurement. In this work, seven factors - customer priority of requirements, implementation complexity, changes in requirements, fault impact of requirements, completeness traceability and execution time are considered to be the primary ingredients of every requirement of the software and every requirement is characterized by the numerical values of these factors. A Java based application system has been developed that takes questionnaires, various parameters/values associated with each of the requirements and generates these factor values for each requirement of the software. These requirement factor values can be used in many ways such as measuring the quality of the software, test case design and optimization, test case prioritization.

Regression testing is important for maintaining software quality. However, the cost of regression testing is relatively high. Test case prioritization is one way to reduce this cost. Test case prioritization techniques sort test cases for regression testing based on their importance. In this paper, we design and implement a test case prioritization method based on the location of a change. The method consists of three steps: (1) clustering test cases, (2) prioritizing the clusters with respect to the relevance of the clusters to a code change, and (3) test case prioritization within each cluster based on metrics. We propose a metric for measuring test case importance based on Requirement Complexity, Code Complexity, and Code Coverage. To evaluate our method, we apply it on a launch interceptor problem program, and measure the inclusiveness and precision for clusters of test cases with respect to code change in specific test cases. Our results show that our proposed change-based prioritization method increases the likelihood of executing more relevant test cases earlier.

Testing is an iterative process of both validating functionality and even more important attempting to break the softwareTest case is used for testing which is a set of test data and test programs (test scripts) and their expected results. This paper details on the tool TCGOJ, test case generation and optimization for Java programs, that generates test cases for any Java programs and produces an optimized result of test cases. Genetic algorithm is used to create and optimize chromosomes which describe the test cases. Mutation and crossover are done for gaining maximum coverage.

Test case prioritization technology improves the efficiency of software testing by optimizing the execution order of test cases, which is an important research topic of software regression testing. In order to solve the problem of requirement-based test case prioritization, this paper proposed a solution based on ant colony optimization algorithm and gave its two different implementation methods: distance-based and index-based implementation. Firstly, a general indicator based on requirements was designed to evaluate the test cases. Secondly, the concept of test case attractivity was proposed, and the definition of the distance between test cases was given based on it. Finally, the main design strategies such as the pheromone update strategy, the optimal solution update strategy, and the local optimal mutation strategy were given. The experimental results show that the method has good global optimization ability, and its overall effect is better than particle swarm optimization algorithm, genetic algorithm and random testing.

Background: Regression testing is very important stage of software maintenance and evolution phase. The software keeps on updating and to preserve the software quality, it needs to be retested every time it is updated. Due to limited resources, complete testing of the software becomes tedious task. The probable solution to this problem is to execute those test cases first that are more important prior to less important test cases. Objective: Optimization methods need to be acquired for efficient test case prioritization in minimum time, while maintaining the quality of the software. Various nature-inspired algorithms like genetic algorithm, particle swarm optimization and ant colony optimization, etc. have been applied for prioritizing test cases. In this paper, we have applied a relatively new nature-inspired optimization method, namely, Bat algorithm that utilizes the echolocation, loudness and pulse emission rate of bats in prioritizing the test cases. Methods: The proposed algorithm is experimented on sample case study of timetable management system and evaluated with the help of popular evaluation metric Average Percentage of Fault Detection. Results: Results have been compared with the baseline approaches i.e. untreated, random and reverse prioritization and well-established optimization method i.e. genetic algorithm and we have found a considerable increase in the value of evaluation metric. Conclusion: This preliminary study shows that the bat algorithm have great potential to solve test case prioritization problems.

Prioritization of test case technique schedules the test suite in an order which will increase the efficiency and effectiveness of the system. The test case executed in an order which enhances the probability of finding the fault and also it finds the severe fault at the early stage. The prioritization of test case is proved to be useful for the regression testing. While much research is going on code coverage based prioritization technique and requirement based test case prioritization technique is not used by many. In this paper, test case prioritization technique based on fault of regression technique is proposed from the requirement specification, to improve the software quality and to increase the fault detection rate. In this paper, test case prioritization is done based the six main factors (i) requirement based on customer priority (ii) based on changes made in requirement specification (iii) complexity in Implementation of code (iv) re-usability (v) flow of application (vi) impact of the fault.

HSP: A hybrid selection and prioritisation of regression test cases based on information retrieval and code coverage applied on an industrial case study

Test case prioritization techniques attempt to reorder test cases in a manner that increases the rate at which faults are detected during regression testing. Coverage-based test case prioritization techniques typically use one of two overall strategies: a total strategy or an additional strategy . These strategies prioritize test cases based on the total number of code (or code-related) elements covered per test case and the number of additional (not yet covered) code (or code-related) elements covered per test case, respectively. In this article, we present a unified test case prioritization approach that encompasses both the total and additional strategies. Our unified test case prioritization approach includes two models ( basic and extended ) by which a spectrum of test case prioritization techniques ranging from a purely total to a purely additional technique can be defined by specifying the value of a parameter referred to as the f p value. To evaluate our approach, we performed an empirical study on 28 Java objects and 40 C objects, considering the impact of three internal factors (model type, choice of f p value, and coverage type) and three external factors (coverage granularity, test case granularity, and programming/testing paradigm), all of which can be manipulated by our approach. Our results demonstrate that a wide range of techniques derived from our basic and extended models with uniform f p values can outperform purely total techniques and are competitive with purely additional techniques. Considering the influence of each internal and external factor studied, the results demonstrate that various values of each factor have nontrivial influence on test case prioritization techniques.

Regression testing is an essential but expensive activity to re-execute all the test cases every time the software updates. Test case prioritization and minimization reduces the cost and efforts required for retesting by prioritizing the test cases based on their importance and minimizing the redundancy. Optimization approaches further enhance the effectiveness of these techniques. In this paper, a discrete and combinatorial gravitational search algorithm is proposed to solve the test case prioritization and minimization problems. Furthermore, an improved version is developed using the chaotic map to update the gravitational constant. The proposed algorithms are compared with the most commonly used algorithm, i.e., genetic algorithm. Three subject programs of varying sizes are used for evaluation. Simulation results prove that the proposed algorithms are more efficient and effective than the genetic algorithm for test case prioritization and minimization. Statistical representation via boxplots of APFD and interval plots of minimized suite size performance metrics, confirms that the improved gravitational search algorithm with chaotic gravitational constant has a more squeezed distribution than the standard gravitational search algorithm.

This study examines the implementation of Test Case Prioritization (TCP) using the Greedy Algorithm (GA) to enhance regression testing efficiency within a financial technology company's software development cycle. With testing durations increasing significantly, this study aims to address inefficiencies by applying the Greedy Algorithm to optimize test suite size and fault detection. The research methodology involves applying the Greedy Algorithm during the Regression Testing phase, comparing the prioritized suite with the original suite using metrics such as Average Percentage Fault Detection (APFD) and Test Suite Size Reduction (TSSR). Results show that the Greedy Algorithm achieved substantial improvements in both test suite size and fault detection effectiveness across different projects. For Project A, the test suite was reduced from 51-22 test cases, achieving a TSSR of 56.8%, with an APFD increase of 206.21%, rising from 0.0853-0.2613. Project B demonstrated even greater optimization, reducing the test suite from 36-8 test cases, resulting in a TSSR of 77.8% and an APFD improvement of 83.92%, rising from 0.3194-0.5875. These outcomes underscore the algorithm’s effectiveness in eliminating redundant test cases, accelerating testing, and enhancing fault detection thereby supporting the company's goal of faster release cycles without compromising quality.

This paper discusses regression testing in software maintenance, focusing on test case prioritization to verify modifications to software functionality efficiently. The primary goal is to rank test cases, prioritizing those covering more code or faults with minimal execution time. The challenge lies in prioritizing numerous test cases generated during development and maintenance. Various algorithms, including greedy approaches and meta-heuristic techniques, address this challenge. The paper introduces a ranking-based non-dominated sorting genetic algorithm (NSGA-2) for test case prioritization, emphasizing cases sensitive to faults caused by modifications or new functionality. Historical data is prioritized, with key objectives including the sensitive index, execution cost, and average percentage of fault detection (APFD). The proposed model is tested on handcrafted and benchmark Java-based applications, comparing its performance to state-of-the-art algorithms in test case prioritization.