Graph Neural Network and Reinforcement Learning Framework for Test Case Prioritization, Selection, and Reduction

Regression testing of the software during its maintenance phase, requires test case prioritization and selection due to the dearth of the allotted time. The resources and the time in this phase are very limited, thus testers tend to use regression testing methods such as test case prioritization and selection. The current study evaluates the effectiveness of testing with two major goals: (1) Least running time and (2) Maximum fault coverage possible. Ant Colony Optimization (ACO) is a well-known soft computing technique that draws its inspiration from nature and has been widely researched, implemented, analyzed, and validated for regression test prioritization and selection. Many versions of ACO approaches have been prolifically applied to find solutions to many non-polynomial time-solvable problems. Hence, an attempt has been made to enhance the performance of the existing ACO_TCSP algorithm without affecting its time complexity. There have been efforts to enhance the exploration space of various paths in each iteration and with elite exploitation, reducing the total number of iterations required to converge to an optimal path. Counterbalancing enhanced exploration with intelligent exploitation implies that the run time is not adversely affected, the same has also been empirically validated. The enhanced algorithm has been compared with the existing ACO algorithm and with the traditional approaches. The approach has also been validated on four benchmark programs to empirically evaluate the proposed Enhanced ACO_TCSP algorithm. The experiment revealed the increased cost-effectiveness and correctness of the algorithm. The same has also been validated using the statistical test (independent t-test). The results obtained by evaluating the proposed approach against other reference techniques using Average Percentage of Faults Detected (APFD) metrics indicate a near-optimal solution. The multiple objectives of the highest fault coverage and least running time were fruitfully attained using the Enhanced ACO_TCSP approach without compromising the complexity of the algorithm.

Flower Pollination Algorithm (FPA) is a significant addition made to Nature Inspired Metaheuristic Optimization Algorithms (NIMOA). It is inspired by the pollination process of flowering plants. In this research, FPA is used for Test Case Prioritization (TCP) in Regression Testing (RT). The algorithm uses code coverage of test cases as the input. The algorithm has no prior information of faults covered by the test cases. This study deals with prioritizing (ordering) the test cases in such a way that only those test cases are executed that covers maximum faults in minimum time of execution. For validation of the results Average Percentage of Fault Detected (APFD) metrics is used. APFD values for different ordering of test cases is calculated for three applications written in Java. The empirical results of APFD metrics for FPA order (TS1) and FPA order (TSp) are better as compared to Random Order of Original Test Suite (TSo) and Reverse Random Order of (TSo). Therefore, this paper states that FPA for TCP gives efficient results in RT.

Background: In today’s era, modifications in a software is a common requirement by customers. When changes are made to existing software, re-testing of all the test cases is required to ensure that the newly introduced changes do not have any unwanted effect on the behavior of the software. However, retesting of all the test cases would not only be time consuming but also expensive. Therefore, there is a need for a technique that reduces the number of tests to be performed. Regression testing is one of the ways to reduce the number of test cases. Selection technique is one such method which seeks to identify the test cases that are relevant to some set of recent changes. Objective: It is evident that most of the studies have used different selection techniques and have focused only on one parameter for achieving reduced test suite size without compromising the performance of regression testing. However, to the best of our knowledge, no study has taken two or more parameters of coverage, and/or execution time in a single testing. This paper presents a hybrid technique that combines both regression test selection using slicing technique and minimization of test cases using modified firefly algorithm with combination of parameters coverage and execution time in a single testing. Methods: A hybrid technique has been described that combines both selection and minimization. Selection of test cases is based upon slicing technique while minimization is done using firefly algorithm. Hybrid technique selects and minimizes the test suite using information on statement coverage and execution time. Results: The proposed technique gives 43.33% much superior result as compared to the other hybrid approach in terms of significantly reduced number of test cases. It shows that the resultant test cases were effective enough to cover 100% of the statements, for all the programs. The proposed technique was also tested on four different programs namely Quadratic, Triangle, Next day, Commission respectively for test suite selection and minimization which gave comparatively superior result in terms of reduction (%) in number of test cases required for testing. Conclusion: The combination of parameters used in slicing based approach, reduces the number of test cases making software testing an economical, feasible and time saving option without any fault in the source code. This proposed technique can be used by software practitioners/experts to reduce time, efforts and resources for selection and minimization of test cases.

Graph Neural Networks (GNNs) are widely applied in 3D computer vision tasks. However, validating their reliability is limited by the high cost of labeling large‐scale test data. Existing test case prioritization techniques for deep learning often rely on single‐dimensional heuristics or mutation‐based analysis (e.g., GraphPrior, PCPrior). However, these methods often limit fault diversity or incur prohibitive computational overhead. To address these issues, this paper proposes LeF‐MTP, a multi‐dimensional test prioritization framework. Unlike these state‐of‐the‐art methods that depend on computationally intensive external mutations, LeF‐MTP directly exploits the model's internal cognitive states. The method characterizes test cases through two dimensions: the predictive uncertainty and feature‐space confusability. These cognitive features are fused via a Random Forest classifier to predict failure probabilities. The resulting priority list is then optimized by a diversity‐aware re‐ranking process based on feature clustering. We evaluated the framework on four 3D point cloud datasets (including ScanObjectNN and S3DIS) across four GNN architectures. Experimental results demonstrate that LeF‐MTP achieves higher fault detection rates than heuristic and mutation‐based baselines, with Average Percentage of Fault Detection (APFD) improvements ranging from 8.79% to 74.69%. Moreover, an efficiency analysis demonstrates that the proposed approach reduces feature generation time compared to mutation‐based methods, validating its practicality for GNN testing.

Software needs modifications and requires revisions regularly. Owing to these revisions, retesting software becomes essential to ensure that the enhancements made, have not affected its bug-free functioning. The time and cost incurred in this process, need to be reduced by the method of test case selection and prioritization. It is observed that many nature-inspired techniques are applied in this area. African Buffalo Optimization is one such approach, applied to regression test selection and prioritization. In this paper, the proposed work explains and proves the applicability of the African Buffalo Optimization approach to test case selection and prioritization. The proposed algorithm converges in polynomial time (O(n2)). In this paper, the empirical evaluation of applying African Buffalo Optimization for test case prioritization is done on sample data set with multiple iterations. An astounding 62.5% drop in size and a 48.57% drop in the runtime of the original test suite were recorded. The obtained results are compared with Ant Colony Optimization. The comparative analysis indicates that African Buffalo Optimization and Ant Colony Optimization exhibit similar fault detection capabilities (80%), and a reduction in the overall execution time and size of the resultant test suite. The results and analysis, hence, advocate and encourages the use of African Buffalo Optimization in the area of test case selection and prioritization.

Test-case prioritization is to schedule the execution order of test cases so as to maximize some objective (e.g., revealing faults early). The existing test-case prioritization approaches separate the process of test-case prioritization and the process of test-case execution by presenting the execution order of all test cases before programmers start running test cases. As the execution information of the modified program is not available for the existing test-case prioritization approaches, these approaches mainly rely on only the execution information of the previous program before modification. To address this problem, we present an adaptive test-case prioritization approach, which determines the execution order of test cases simultaneously during the execution of test cases. In particular, the adaptive approach selects test cases based on their fault-detection capability, which is calculated based on the output of selected test cases. As soon as a test case is selected and runs, the fault-detection capability of each unselected test case is modified according to the output of the latest selected test case. To evaluate the effectiveness of the proposed adaptive approach, we conducted an experimental study on eight C programs and four Java programs. The experimental results show that the adaptive approach is usually significantly better than the total test-case prioritization approach and competitive to the additional test-case prioritization approach. Moreover, the adaptive approach is better than the additional approach on some subjects (e.g, replace and schedule).

Background: In Regression testing when any changes made to already tested program it should not affect to other part of program. When some part of code is modified then it is necessary to validate the modified code. In the life cycle of software development, regression testing is an important and expensive activity. Objective: Our objective is to save regression testing time by reducing the cost and time of retesting of the modified code as well as affected components of the program. Objective is to prioritize the test case for object oriented program based on early fault detection. Methods: A new model is proposed using fuzzy inference system for regression testing. This paper presents a fuzzy inference system based on the use of inputs like fault detection rate, execution time and requirement coverage. The proposed system allows tester to prioritize test case based on linguistic rules. Results: In this paper performance is measured by using Average Percentage Fault Detection metric. We analysed for both prioritized and non-prioritized test suite using average percentage fault detection metric. Conclusion: We developed fuzzy expert model which helps to takes better decision than other expert system for regression testing. We conclude that, prioritization of test case will decrease the regression testing time.

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.

Regression testing (RT) is an expensive activity. It is applied on a modified program to enhance confidence and reliability by ensuring that the changes are accurately true and have not affected the unmodified portions of the SUT. Due to limited resources, it is not practical to re-run each test cases (TC). To improve the regression testing's effectiveness, the TCs should be arranged according to some objective function or criteria. Test case prioritization (TCP) arranges TCs in an order for execution that enhances their effectiveness by satisfying some testing goals. The highest priority assigned to TCs must execute before the TCs with low priority by virtue of some performance goal. Numerous goals are possible to achieve of which one such goal is rate of fault detection (RFT) in which the faults are surfaced as quickly as possible within the testing process. In this paper, a novel technique is suggested to prioritize the TCs that increase its effectiveness in detecting faults. The effectiveness of the proposed method is compared and matched with other prioritization approaches with the help of Average Percentage of Fault Detection (APFD) metric from which charts have been prepared.

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

Detecting the dependency between integration test cases plays a vital role in the area of software test optimization. Classifying test cases into two main classes – dependent and independent – can be employed for several test optimization purposes such as parallel test execution, test automation, test case selection and prioritization, and test suite reduction. This task can be seen as an imbalanced classification problem due to the test cases’ distribution. Often the number of dependent and independent test cases is uneven, which is related to the testing level, testing environment and complexity of the system under test. In this study, we propose a novel methodology that consists of two main steps. Firstly, by using natural language processing we analyze the test cases’ specifications and turn them into a numeric vector. Secondly, by using the obtained data vectors, we classify each test case into a dependent or an independent class. We carry out a supervised learning approach using different methods for handling imbalanced datasets. The feasibility and possible generalization of the proposed methodology is evaluated in two industrial projects at Bombardier Transportation, Sweden, which indicates promising results.

Software testing is an important and complex part of the software development life cycle. Along with version changes and defect repairs of the software system under test, regression testing is required to ensure that the modified parts have no impact on the unmodified parts. In a resource-constrained environment, it is necessary to select a more valuable test case from the test case library to execute first. However, the existing prioritization methods of test cases are still insufficient in terms of Average Percentage of Faults Detected (APFD) and time execution performance, and there is a problem oflarge search space. Aiming at the test case priority ranking problem, this paper proposes a meta-heuristic test case prioritization method based on a hybrid model to reduce test cost. This method first establishes a hybrid model by using the correlation between test cases and the importance of test data, and then uses an improved firefly algorithm based on the hybrid model to find an optimal test sequence. This article has carried out experiments on three benchmark test programs. The test suite is from Software-artifact Infrastructure Repository (1 SIR). The experimental results show that the method proposed in this paper has better performance in terms of APFD and time execution compared with existing methods, such as Greedy, Particle Swarm optimization (PSO) and Firefly Algorithm (FA).1https://sir.csc.ncsu.edu/content/sir.php

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.

Test case selection is the maintenance technique regarding the concept of choosing the appropriate representative of the modified program that has to be changed depending upon the new requirements added for the next modification. The main problem of updating software is the amounts of the test suite that is generated for the tests increases, which can drop the performance of using the new code that added to the previous program. According to this, execution and testing time will increase, including the complexity of integrating the codes also increase. Therefore, the test suite minimization approaches are offered to solve these problems. The objective of proposing the design based technique is to refine the competency of using test case selection to control the large programs by applying four algorithms, which are testing test case, classification, deletion, and selection. The result of determining the size reduction is greater than random selection, general regression technique, and test case prioritization as about 28.00%, 17.00%, and 11.00% approximately.