Evolutionary cost-cognizant regression test case prioritization for object-oriented programs - Bello, AbdulKarim (2019)
Regression testing is conducted to ensure that changes made to a software satisfy the requirements and do not adversely introduce bugs to its existing functionalities. It involves the process of re-testing software after modifications. Ideally, to perform regression testing is to re-execute all the test cases on the modified software. Re-execution of all test cases can be expensive as there might be wasting resources, could be costly and time consuming. The three regression testing techniques are test cases selection (TCS), test suite minimization (TSM) and test cases prioritization (TCP). TCS attempts to identify test cases that have the same relevance to some set of changes. This technique has the problem of selecting a significant number of test cases even for small changes made to a software. TSM removes obsolete test cases from the test suite. The drawback in minimizing the test suite is it could reduce the quality of test suite. To overcome the limitations of TCS and TSM, researchers proposed TCP to avoid test case discarding. TCP deals with the problem of test discarding and attempts to order test cases in an optimized order such that those with highest priority are executed earlier. One such criterion, is the rate of fault detection to measures how fast test cases revealed faults. Improved rate of faults detection can give developers chance to debug the faulty software earlier. To improve the rate of fault detection during several TCP approaches are proposed for regression testing. Reports from literature show that these approaches are associated with some limitations. Most of the approaches usually considered test costs and fault severity to be uniform. In practice test case cost and fault severity can vary, and in such cases the previous metric and approaches designed to improve fault detection of a prioritized test cases can produced an unsatisfactory result. The recent trend of software development uses OO paradigm. Therefore, this study proposed a cost-cognizant TCP approach for object-oriented software that uses path-based integration testing to identify the possible execution path extracted 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 rate severity of fault detection per unit test cost. The proposed technique is named Evolutionary Cost-Cognizant Regression Test Case Prioritization (ECRTP). The experiment conducted on the proposed approach and the result obtained was empirically evaluated and compared with some existing approaches to determine its efficiency and effectiveness. The average percentage of fault detection per cost (APFDc) metric was employed to measure the average cost per severity detection. The analysis showed significant differences for both the effectiveness, efficiency and APFDc of the ECRTP over existing approaches such as RanPrio, RevPrio, NonPrio, JaNaMa and EvolRTP, which make ECRTP a promising approach to use for regression testing. In the future, there is a need to extend the scope of this work by incorporating information from the latest regression testing, consider addition object-oriented metrics such as coupling and cohesion, and incorporate multi-objective evolutionary processes. There is also a need to consider implementing this strategy for dynamic object-oriented languages such as Python, Lisp, and Smalltalk.