scholarly journals Applying test case prioritization to software microbenchmarks

2021 ◽  
Vol 26 (6) ◽  
Author(s):  
Christoph Laaber ◽  
Harald C. Gall ◽  
Philipp Leitner
Keyword(s):  
Software Evolution ◽  
Regression Testing ◽  
Attractive Alternative ◽  
Test Case ◽  
Test Case Prioritization ◽  
Unit Testing ◽  
Effective Technique ◽  
Average Percentage ◽  
Performance Effectiveness ◽  
Test Suites

AbstractRegression testing comprises techniques which are applied during software evolution to uncover faults effectively and efficiently. While regression testing is widely studied for functional tests, performance regression testing, e.g., with software microbenchmarks, is hardly investigated. Applying test case prioritization (TCP), a regression testing technique, to software microbenchmarks may help capturing large performance regressions sooner upon new versions. This may especially be beneficial for microbenchmark suites, because they take considerably longer to execute than unit test suites. However, it is unclear whether traditional unit testing TCP techniques work equally well for software microbenchmarks. In this paper, we empirically study coverage-based TCP techniques, employing total and additional greedy strategies, applied to software microbenchmarks along multiple parameterization dimensions, leading to 54 unique technique instantiations. We find that TCP techniques have a mean APFD-P (average percentage of fault-detection on performance) effectiveness between 0.54 and 0.71 and are able to capture the three largest performance changes after executing 29% to 66% of the whole microbenchmark suite. Our efficiency analysis reveals that the runtime overhead of TCP varies considerably depending on the exact parameterization. The most effective technique has an overhead of 11% of the total microbenchmark suite execution time, making TCP a viable option for performance regression testing. The results demonstrate that the total strategy is superior to the additional strategy. Finally, dynamic-coverage techniques should be favored over static-coverage techniques due to their acceptable analysis overhead; however, in settings where the time for prioritzation is limited, static-coverage techniques provide an attractive alternative.

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

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.

Test Case Prioritization—ANT Algorithm With Faults Severity

2020 ◽  
Author(s):  
Andreea Vescan ◽  
Camelia-M Pintea ◽  
Petrică C Pop
Keyword(s):  
Selection Criterion ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Testing Time ◽  
Average Percentage ◽  
Prioritization Method ◽  
The Cost ◽  
Run Test

Abstract Regression testing is applied whenever a code changes, ensuring that the modifications fixed the fault and no other faults are introduced. Due to a large number of test cases to be run, test case prioritization is one of the strategies that allows to run the test cases with the highest fault rate first. The aim of the paper is to present an optimized test case prioritization method inspired by ant colony optimization, test case prioritization–ANT. The criteria used by the optimization algorithm are the number of faults not covered yet by the selected test cases and the sum of severity of the faults. The cost, i.e. time execution, for test cases is considered in the computation of the pheromone deposited on the graph’s edges. The average percentage of fault detected metric, as best selection criterion, is used to uncover maximum faults with the highest severity, and reducing the regression testing time. Several experiments are considered, detailed and discussed, comparing various algorithm parameter’s alternatives. A benchmark project is also used to validate the proposed approach. The obtained results are encouraging, being a cornerstone for new perspectives to be considered.

scholarly journals STUDY OF TEST CASE PRIORITIZATION TECHNIQUE USING APFD

2013 ◽  
Vol 10 (3) ◽  
pp. 1475-1481
Author(s):  
Rahul Gupta ◽  
Akhilesh Kumar Yadav
Keyword(s):  
Fault Detection ◽  
Software Development ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Average Percentage

Regression testing is used to ensure that bugs are fixed and new functionality introduce in a new version of a software that don't adversely affect the original functionality inherited from the previous version.Regression testing is one of the most complaining activities of software development and maintenance.Unluckily, It may have feeble resources to allow for the re-execution of all test cases during regression testing. In this situation the use of test case prioritization is profitable because the best appropriate test cases are executed first. In this paper we are proposing an algorithm to prioritize test cases based on rate of fault detection and impact of fault.The proposed algorithm recognises the exhausting fault at earlier stage of the testing process.We are using an Average Percentage of Faults Detected (APFD) metric to determine the effectiveness of the new test case arrangements.

scholarly journals Using Fuzzy Logic in Test Case Prioritization for Regression Testing Programs with Assertions

2014 ◽  
Vol 2014 ◽  
pp. 1-9 ◽  
Author(s):  
Ali M. Alakeel
Keyword(s):  
Fuzzy Logic ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Software Developers ◽  
Novel Approach ◽  
History Of ◽  
Supporting Tool

Program assertions have been recognized as a supporting tool during software development, testing, and maintenance. Therefore, software developers place assertions within their code in positions that are considered to be error prone or that have the potential to lead to a software crash or failure. Similar to any other software, programs with assertions must be maintained. Depending on the type of modification applied to the modified program, assertions also might have to undergo some modifications. New assertions may also be introduced in the new version of the program, while some assertions can be kept the same. This paper presents a novel approach for test case prioritization during regression testing of programs that have assertions using fuzzy logic. The main objective of this approach is to prioritize the test cases according to their estimated potential in violating a given program assertion. To develop the proposed approach, we utilize fuzzy logic techniques to estimate the effectiveness of a given test case in violating an assertion based on the history of the test cases in previous testing operations. We have conducted a case study in which the proposed approach is applied to various programs, and the results are promising compared to untreated and randomly ordered test cases.

scholarly journals Evolutionary Cost-cognizant Test Case Selection and Prioritization for Object-Oriented Programs

2019 ◽  
Vol 8 (6S3) ◽  
pp. 149-153
Keyword(s):  
Unit Cost ◽  
Object Oriented ◽  
Arbitrary Point ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Integration Testing ◽  
Maximum Benefit ◽  
Regression Test

Test case prioritization (TCP) is a software testing technique that finds an ideal ordering of test cases for regression testing, so that testers can obtain the maximum benefit of their test suite, even if the testing process is stop at some arbitrary point. The recent trend of software development uses OO paradigm. This paper proposed a cost-cognizant TCP approach for object-oriented software that uses path-based integration testing. Path-based integration testing will identify the possible execution path and extract these paths from the Java System Dependence Graph (JSDG) model of the source code using forward slicing technique. Afterward evolutionary algorithm (EA) was employed to prioritize test cases based on the severity detection per unit cost for each of the dependent faults. The proposed technique was known as Evolutionary Cost-Cognizant Regression Test Case Prioritization (ECRTP) and being implemented as regression testing approach for experiment.

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.

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.

Regression Test Case Prioritization Based on Fixed Size Candidate Set ART Algorithm

2020 ◽  
Vol 30 (03) ◽  
pp. 291-320
Author(s):  
Rongcun Wang ◽  
Zhengmin Li ◽  
Shujuan Jiang ◽  
Chuanqi Tao
Keyword(s):  
Fault Detection ◽  
Empirical Studies ◽  
Cost Effective ◽  
Regression Testing ◽  
Test Case ◽  
Test Case Prioritization ◽  
Fixed Size ◽  
C Programs ◽  
Testing Algorithm ◽  
Candidate Set

Regression testing is a very time-consuming and expensive testing activity. Many test case prioritization techniques have been proposed to speed up regression testing. Previous studies show that no one technique is always best. Random strategy, as the simplest strategy, is not always so bad. Particularly, when a test suite has higher fault detection capability, the strategy can generate a better result. Nevertheless, due to the randomness, the strategy is not always as satisfactory as expected. In this context, we present a test case prioritization approach using fixed size candidate set adaptive random testing algorithm to reduce the effect of randomness and improve fault detection effectiveness. The distance between pair-wise test cases is assessed by exclusive OR. We designed and conducted empirical studies on eight C programs to validate the effectiveness of the proposed approach. The experimental results, confirmed by a statistical analysis, indicate that the approach we proposed is more effective than random and the total greedy prioritization techniques in terms of fault detection effectiveness. Although the presented approach has comparable fault detection effectiveness to ART-based and the additional greedy techniques, the time cost is much lower. Consequently, the proposed approach is much more cost-effective.

Sign in / Sign up

Export Citation Format

Share Document