scholarly journals Test Suite Reduction and Prioritization Framework in Regression Testing

2021 ◽  
Vol 12 (3) ◽  
pp. 1947-1951
Author(s):  
Samaila Musa Et.al
Keyword(s):  
Regression Testing ◽  
Test Suite ◽  
Test Cases ◽  
Future Plan ◽  
Average Percentage ◽  
Sample Test ◽  
Test Suite Reduction ◽  
Prioritization Framework ◽  
New Framework

Most of the test cases minimization reduced test cases during regression testing   to generate new test suite to cover the same software requirements.The objective of this paper is to present new framework that integrate the idea of minimization and prioritization.Hence, reduction and prioritization able to reduce test cases based on the statements covered by the previous test cases to avoid redundancy.Beginning from the reduction of the test cases, followed by  weighted prioritizationaccording to their usefulness.The  framework was tested using sample test suite and the results obtained shown increases on the average percentage  of faults detection (APFD). Future plan is to test on the larger size of test suite.

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.

Search-Based Regression Testing Optimization

2021 ◽  
Vol 12 (2) ◽  
pp. 1-20
Author(s):  
Nagwa R. Fisal ◽  
Abeer Hamdy ◽  
Essam A. Rashed
Keyword(s):  
Maintenance Phase ◽  
Bat Algorithm ◽  
Regression Testing ◽  
Test Suite ◽  
Test Cases ◽  
Software Projects ◽  
Java Programs ◽  
Optimal Surface ◽  
Test Suite Reduction ◽  
The Cost

Regression testing is one of the essential activities during the maintenance phase of software projects. It is executed to ensure the validity of an altered software. However, as the software evolves, regression testing becomes prohibitively expensive. In order to reduce the cost of regression testing, it is mandatory to reduce the size of the test suite by selecting the most representative test cases that do not compromise the effectiveness of the regression testing in terms of fault-detection capability. This problem is known as test suite reduction (TSR) problem, and it is known to be an NP-complete. The paper proposes a multi-objective adapted binary bat algorithm (ABBA) to solve the TSR problem. The original binary bat (OBBA) algorithm was adapted to enhance its exploration capabilities during the search for a Pareto-optimal surface. The effectiveness of the ABBA was evaluated using six Java programs with different sizes. Experimental results showed that for the same fault discovery rate, the ABBA is capable of reducing the test suite size more than the OBBA and the BPSO.

scholarly journals Using Global Constraints to Automate Regression Testing

AI Magazine ◽  
2017 ◽  
Vol 38 (1) ◽  
pp. 73-87
Author(s):  
Arnaud Gotlieb ◽  
Dusica Marijan
Keyword(s):  
Product Line ◽  
Regression Testing ◽  
Test Suite ◽  
Global Constraints ◽  
Test Case ◽  
Delivery Mode ◽  
Test Cases ◽  
High Quality ◽  
Test Suite Reduction ◽  
Test Requirements

Nowadays, any communicating or autonomous systems rely on high-quality software-based components. To ensure a sufficient level of quality, these components must be thoroughly verified before being released and being deployed in operational settings. Regression testing is a crucial verification process that executes any new release of a software-based component against previous versions of the component, with existing test cases. However, the selection of test cases in regression testing is challenging as the time available for testing is limited and some selection criteria must be respected. This problem, coined as Test Suite Reduction (TSR), is usually addressed by validation engineers through manual analysis or by using approximation techniques. Even if the underlying optimization problem is untractable in theory, solving it in practice is crucial when there are pressing needs to release high-quality components while at the same time reducing the time-to-market of new software releases. In this paper, we address the TSR problem with sound Artificial intelligence techniques such as Constraint Programming (CP) and global constraints. By associating each test case a cost-value aggregating distinct criteria, such as execution time, priority or importance due to the error-proneness of each test case, we propose several constraint optimization models to find a subset of test cases covering all the test requirements and optimizing the overall cost of selected test cases. Our models are based on a combination of NVALUE, GLOBALCARDINALITY, and SCALAR_PRODUCT, three well-known global constraints that can faithfully encode the coverage relation between test cases and test requirements. Our contribution includes the reuse of existing preprocessing rules to simplify the problem before solving it and the design of structure-aware heuristics, which take into account the notion of costs, associated with test cases. The work presented in this paper has been motivated by an industrial application in the communication domain. Our overall goal is to develop a constraint-based approach of test suite reduction that can be deployed to test a complete product line of conferencing systems in continuous delivery mode. By implementing this approach in a software prototype tool and experimentally evaluated it on both randomly generated instances and industrial instances, we hope to foster a quick adoption of the technology.

scholarly journals A Prioritization Approach for Regression Test Cases Based on a Revised Genetic Algorithm

2021 ◽  
Vol 50 (3) ◽  
pp. 443-457
Author(s):  
Thamer Alrawashdeh ◽  
Fuad ElQirem ◽  
Ahmad Althunibat ◽  
Roba Alsoub
Keyword(s):  
Genetic Algorithm ◽  
Software Testing ◽  
Regression Testing ◽  
Test Cases ◽  
Average Percentage ◽  
Lower Priority ◽  
Regression Test ◽  
Predefined Criterion ◽  
Good Coverage ◽  
Selection Of

The regression testing is a software-based testing approach executed to verify that changes made to the softwaredo not affect the existing functionality of the product. On account of the constraints of time and cost, it isimpractical to re-execute all the test cases for software whenever a change occurs. In order to overcome sucha problem in the selection of regression test cases, a prioritization technique should be employed. On the basisof some predefined criterion, the prioritization techniques create an execution schedule for the test cases, sothe higher priority test cases can be performed earlier than the lower priority test cases in order to improvethe efficiency of the software testing. Many prioritization criteria for regression test cases have been proposedin software testing literature; however, most of such techniques are code-based. Keeping in view this fact, thisresearch work has proposed a prioritization approach for regression test cases generated from software specificationswhich are based on the criterion of the Average Percentage Transition Coverage (APTC) by using arevised genetic algorithm. This criterion evaluates the rate of transitions coverage by incorporating knowledgeabout the significance of transitions between activates in the form of weights. APTC has been used as a fitnessevaluation function in a genetic algorithm to measure the effectiveness of a test cases sequence. Moreover, inorder to improve the coverage percentage, the proposed approach has revised the genetic algorithm by solvingthe problem of the optimal local solution. The experimental results show that the proposed approach demonstratesa good coverage performance with less execution time as compared to the standard genetic algorithmand some other prioritization techniques.

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

Test Pair Selection for Test Case Prioritization in Regression Testing for WS-BPEL Programs

2013 ◽  
Vol 10 (1) ◽  
pp. 73-102 ◽  
Author(s):  
Lijun Mei ◽  
Yan Cai ◽  
Changjiang Jia ◽  
Bo Jiang ◽  
W.K. Chan
Keyword(s):  
Web Services ◽  
Structural Similarity ◽  
Regression Testing ◽  
Test Pair ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Empirical Results ◽  
Selection For

Many web services not only communicate through XML-based messages, but also may dynamically modify their behaviors by applying different interpretations on XML messages through updating the associated XML Schemas or XML-based interface specifications. Such artifacts are usually complex, allowing XML-based messages conforming to these specifications structurally complex. Testing should cost-effectively cover all scenarios. Test case prioritization is a dimension of regression testing that assures a program from unintended modifications by reordering the test cases within a test suite. However, many existing test case prioritization techniques for regression testing treat test cases of different complexity generically. In this paper, the authors exploit the insights on the structural similarity of XML-based artifacts between test cases in both static and dynamic dimensions, and propose a family of test case prioritization techniques that selects pairs of test case without replacement in turn. To the best of their knowledge, it is the first test case prioritization proposal that selects test case pairs for prioritization. The authors validate their techniques by a suite of benchmarks. The empirical results show that when incorporating all dimensions, some members of our technique family can be more effective than conventional coverage-based techniques.

An Effective Approach to Test Suite Reduction and Fault Detection Using Data Mining Techniques

2017 ◽  
Vol 8 (4) ◽  
pp. 1-31 ◽  
Author(s):  
B. Subashini ◽  
D. Jeya Mala
Keyword(s):  
Data Mining ◽  
Attribute Reduction ◽  
Test Suite ◽  
Test Cases ◽  
Data Mining Techniques ◽  
Coverage Analysis ◽  
Quality Product ◽  
Irrelevant Attributes ◽  
Test Suite Reduction ◽  
Using Data

Software testing is used to find bugs in the software to provide a quality product to the end users. Test suites are used to detect failures in software but it may be redundant and it takes a lot of time for the execution of software. In this article, an enormous number of test cases are created using combinatorial test design algorithms. Attribute reduction is an important preprocessing task in data mining. Attributes are selected by removing all weak and irrelevant attributes to reduce complexity in data mining. After preprocessing, it is not necessary to test the software with every combination of test cases, since the test cases are large and redundant, the healthier test cases are identified using a data mining techniques algorithm. This is healthier and the final test suite will identify the defects in the software, it will provide better coverage analysis and reduces execution time on the software.

Search for Prioritized Test Cases during Web Application Testing

2019 ◽  
Vol 10 (2) ◽  
pp. 1-26 ◽  
Author(s):  
Munish Khanna ◽  
Naresh Chauhan ◽  
Dilip Kumar Sharma
Keyword(s):  
Web Application ◽  
Web Applications ◽  
Greedy Algorithms ◽  
Regression Testing ◽  
Test Sequence ◽  
Test Case ◽  
Test Cases ◽  
Average Percentage ◽  
Heuristic Approaches ◽  
Better Than

Regression testing of evolving software is a critical constituent of the software development process. Due to resources constraints, test case prioritization is one of the strategies followed in regression testing during which a test case that satisfies predefined objectives the most, as the tester perceives, would be executed the earliest. In this study, all the experiments were performed on three web applications consisting of 65 to 100 pages with lines of code ranging from 5000 to 7000. Various state-of-the-art approaches such as, heuristic approaches, Greedy approaches, and meta heuristic approaches were applied so as to identify the prioritized test sequence which maximizes the value of average percentage of fault detection. Performance of these algorithms was compared using different parameters and it was concluded that the Artificial Bee Colony algorithm performs better than all. Two novel greedy algorithms are also proposed in the study, of which the goal is to smartly manage the state of a tie, where a tie exhibits the condition that all the test cases participating in the tie are of equal significance in achieving the objective. It has also been validated that the performance of these novel proposed algorithm(s) is better than that of traditionally followed greedy approach, most of the time.

Optimal Test Case Selection Using Ant Colony and Rough Sets

2020 ◽  
Vol 11 (2) ◽  
pp. 1-14
Author(s):  
Angelin Gladston ◽  
Niranjana Devi N.
Keyword(s):  
Optimization Technique ◽  
Computational Effort ◽  
Ant Colony ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Optimal Test ◽  
Average Percentage ◽  
Test Case Selection ◽  
Case Selection

Test case selection helps in improving quality of test suites by removing ambiguous, redundant test cases, thereby reducing the cost of software testing. Various works carried out have chosen test cases based on single parameter and optimized the test cases using single objective employing single strategies. In this article, a parameter selection technique is combined with an optimization technique for optimizing the selection of test cases. A two-step approach has been employed. In first step, the fuzzy entropy-based filtration is used for test case fitness evaluation and selection. In second step, the improvised ant colony optimization is employed to select test cases from the previously reduced test suite. The experimental evaluation using coverage parameters namely, average percentage statement coverage and average percentage decision coverage along with suite size reduction, demonstrate that by using this proposed approach, test suite size can be reduced, reducing further the computational effort incurred.

Sign in / Sign up

Export Citation Format

Share Document