Regression Testing Effort Research Articles

Estimation Approaches of Machine Learning in Scrum Projects: A Review

Abstract: It is inevitable for any successful IT industry not to estimate the effort, cost, and duration of their projects. As evident by Standish group chaos manifesto that approx 43% of the projects are often delivered late and entered crises because of over budget and less required functions. Improper and inaccurate estimation of software projects leads to a failure, and therefore it must be considered in true letter and spirit. When Agile principle-based process models (e.g. Scrum) came into the market, a significant change can be seen. This change in culture proves to be a boon forstrengthening the collaboration betweendeveloper and customer.Estimation has always been challenging in Agile as requirements are volatile. This encourages researchersto work on effort estimation. There are many reasons for the gap between estimated and actual effort, viz., project, people, and resistance factors, wrong use of cost drivers, ignorance of regression testing effort, understandability of user story size and its associated complexity, etc. This paperreviewed the work of numerous authors and potential researchers working on bridging the gap of actual and estimated effort. Through intensive and literature review, it can be inferred that machine learning models clearly outperformed non-machine learning and traditional techniques of estimation. Keywords: Machine Learning, Scrum, Scrum Projects, Effort Estimation, Agile Software Development

Optimizing the Software Testing Problem Using Search-Based Software Engineering Techniques

Software testing is a fundamental step in the software development lifecycle. Its purpose is to evaluate the quality of software applications. Regression testing is an important testing methodology in software testing. The purpose of regression testing is to validate the software after each change of its code. This involves adding new test cases to the test suite and running the test suite as the software changes, making the test suite larger. The cost and time of the project are affected by the test suite size. The challenge is to run regression testing with a smaller number of test cases and larger amount of software coverage. Minimization of the test suite with maximization of the software coverage is an NP-complete problem. Search-based software engineering is an important topic in software engineering, which addresses software engineering optimization problems to find the optimal/approximate solution of the given problem. This study investigated an approach to reducing the regression testing effort and saving time. It also solved the regression testing optimization problem by achieving the maximum test suite coverage with the minimum test suite size. Several experiments were conducted to obtain the optimal solutions for the regression testing problem. We propose an optimization methodology that combines a genetic algorithm and a greedy algorithm to optimize regression testing by respectively maximizing the software test coverage and minimizing the test suite size. The proposed methodology can conveniently deliver fault-free, fully covered, and powerful programs for mission-critical functions. It can be applied to test a real-time system that has high requirements for reliability, security, and safety.

A Review for Improving Software Change using Traceability Model with Test Effort Estimation

Maintaining a software system includes tasks such as fixing defects, adding new features, or modifying the software (software changes) to accommodate different environments. Then, the modified software system needs to be tested, to ensure the changes will not having any adverse effects on the previously validated code. Regression testing is one of the approaches which software tester used to test the software system. The traditional regression testing strategy was to repeat all the previous tests and retesting all the features of the program even for small modifications. For programming with thousand lines of codes (LOC), the cost of retesting the entire system is expensive if attempted after every change. This practice is becoming increasingly difficult because of the demand for testing the new functionalities and correcting errors with limited resources. Numerous techniques and tools have been proposed and developed to reduce the costs of regression testing and to aid regression testing processes, such as test suite reduction, test case prioritization, and test case done on the thresholds and weightings used in regression testing. However, there is still need to study on the software traceability model of coverage analysis in software changes during regression testing and test effort estimation on regression testing. Hence, this paper describes the proposal for improving software changes with hybrid traceability model and test effort estimation during regression testing. We will explain our proposed work including the problem background, the intended research objectives, literature review and plan for future implementation. This study is expected to contribute in developing hybrid traceability model for large software development project to support software changes during regression testing with test estimation approach and expected to reduce operational cost during the implementation on software maintenance. Also, it is hoped that an efficient and improve solution to regression testing can be realized, thus, gives the benefits to software testers and project manager manage the software maintenance task since it is a critical part in software project development.

Requirement Prioritization of Complex Web 2.0 Application based on Effects on Regression Testing

Web 2.0 applications are complex information systems. Likewise any desktop applications, web applications are complex and require effective requirement prioritization preceded by effective decision aspect prioritization by involving diverse stakeholders. During the release of new increments, objective is to provide value to the software and simultaneously lowering the regression testing effort. This can be achieved by implementing all highest priority requirements along with those dependent on them so that next increments implemented requirements independent of already implemented ones. The challenges involved in aspect selection, requirement prioritization, and effective selection of the security requirements of Web 2.0 application makes its incremental deliveries a complex task as compared to that of desktop applications. The proposed requirement prioritization process is hybrid approach i.e. Based on combination of negotiations and methods to prioritize both decision aspects and software requirements. This technique reduces regression testing effort by taking an impact on regression testing as one of the parameters during prioritization and overcomes various problems related to prioritization of web 2.0 applications. This technique is applied on live system of “Virtual Classroom”, by employing three stakeholder groups with total 8 stakeholders. Results were promising since it resulted in the successful delivery of web application due to effective aspect and requirement prioritization thereby leading to reduced regression testing effort.

Regression Test Case Selection &PrioritizationUsing Dependence Graph and Genetic Algorithm

Regression testing is very important process in software maintenance. Unfortunately, it is costly and time consuming to allow for the re-execution of all test cases during regression testing. The challenge in regression testing is the selection of best test cases from the existing test suite.This paper presents an evolutionary regression test case prioritization for object-oriented software based on extended system dependence graph model of the affected program using genetic algorithm. The approach is based on optimization of selected test case from dependency analysis of the source codes. The goal is to identify changes in a method's body due to data dependence, control dependence and dependent due to object relation such as inheritance and polymorphism, select the test cases based on affected statements and ordered them based on their fitness by using GA.The number of affected statements determined how fit a test case is good for regression testing. A case study is reported to provide evidence of the feasibility of the approach and its benefits in increasing the rate of fault detection and reduction in regression testing effort compared with retest-all. It was shown that our approach needs 30% of the test cases to cover all the faults, while 80% is needed to cover all the faults using retest-all, which is time consuming and costly.

Regression Test Reduction for Object-Oriented Software: A Control Call Graph Based Technique and Associated Tool

This paper presents a selective regression testing technique and an associated tool for object-oriented software. The technique is based on the concept of Control Call Graphs, which are a reduced form of traditional Control Flow Graphs. It uses static analysis of the source code of the program. The developed tool (1) identifies the Control Call Paths potentially impacted by changes, (2) selects, from an existing test suite, the appropriate test cases, and (3) generates new JUnit test cases for control call paths that are not covered by existing tests (new ones, or those whose structure has been modified after changes). In this way, the approach supports an incremental update of the test suite. The selected JUnit test cases, including the new ones, are automatically executed. Three concrete case studies are reported to provide evidence of the feasibility of the approach and its benefits in terms of reduction of regression testing effort.

Software Change Validation before Change Implementation

Software maintenance is the most demanding and most expensive task of the software development. Quality of the regression testing decides the quality of the maintained software. Several approaches, code-based and model- based are recommended in literature to minimize the regression test suit. This paper proposes the model based technique to validate the change before implementation. The approach considers the SRS and UML class diagram for earlier change validation. We update the SRS for including the requested change and prepare difference_SRS file that contain the differences of old and new SRS. After imposing these changes in UML class diagram, dependency matrix for both old and new class diagram and a difference dependency matrix from these two dependency matrices is generated we map the entire changes one by one form difference_SRS file to difference dependency matrix. Using the approach, we have concluded a case study and observed impressive gains in terms of less requirement of regression testing effort. The result shows that the approach allows the implementation of change only after validating the requested change after the design phase. Keywords: Software Change Validation, SRS, Regression Testing, Class Diagram, UML and Dependency Matrix.

Scaling regression testing to large software systems

When software is modified, during development and maintenance, it is <i>regression tested</i> to provide confidence that the changes did not introduce unexpected errors and that new features behave as expected. One important problem in regression testing is how to select a subset of test cases, from the test suite used for the original version of the software, when testing a modified version of the software. Regression-test-selection techniques address this problem. Safe regression-test-selection techniques select every test case in the test suite that may behave differently in the original and modified versions of the software. Among existing safe regression testing techniques, efficient techniques are often too imprecise and achieve little savings in testing effort, whereas precise techniques are too expensive when used on large systems. This paper presents a new regression-test-selection technique for Java programs that is safe, precise, and yet scales to large systems. It also presents a tool that implements the technique and studies performed on a set of subjects ranging from 70 to over 500 KLOC. The studies show that our technique can efficiently reduce the regression testing effort and, thus, achieve considerable savings.

An empirical study of regression test selection techniques

Regression testing is the process of validating modified software to detect whether new errors have been introduced into previously tested code and to provide confidence that modifications are correct. Since regression testing is an expensive process, researchers have proposed regression test selection techniques as a way to reduce some of this expense. These techniques attempt to reduce costs by selecting and running only a subset of the test cases in a program's existing test suite. Although there have been some analytical and empirical evaluations of individual techniques, to our knowledge only one comparative study, focusing on one aspect of two of these techniques, has been reported in the literature. We conducted an experiment to examine the relative costs and benefits of several regression test selection techniques. The experiment examined five techniques for reusing test cases, focusing on their relative ablilities to reduce regression testing effort and uncover faults in modified programs. Our results highlight several differences between the techiques, and expose essential trade-offs that should be considered when choosing a technique for practical application.

When are two classes equivalent?

Software written using an object-oriented programming language is made up of classes, which are compile-time entities and objects, that represent the run-tlme instances of these classes. When the software evolves from one version to another, some of these classes might undergo changes. An important question concerning this evolution is whether the changed class needs to be retested. Research in the area of regression testing has focussed on techniques for optimizing the regression testing effort. We have proposed elsewhere a language-based approach to regression testing that exploits features specific to an object-oriented language to reason about the need to retest an evolved class. The basis for our research is the intuition that when a class can be shown to be equivalent to its original tested version, regression testing may not always be required. We have identified four types of equivalence between a class and its evolved counterpart. In this article, we discuss these equivalence categories and point out their impact on retest effort.