scholarly journals REDUNET: reducing test suites by integrating set cover and network-based optimization

2020 ◽  
Vol 5 (1) ◽  
Author(s):  
Misael Mongiovì ◽  
Andrea Fornaia ◽  
Emiliano Tramontana

Abstract The availability of effective test suites is critical for the development and maintenance of reliable software systems. To increase test effectiveness, software developers tend to employ larger and larger test suites. The recent availability of software tools for automatic test generation makes building large test suites affordable, therefore contributing to accelerating this trend. However, large test suites, though more effective, are resources and time consuming and therefore cannot be executed frequently. Reducing them without decreasing code coverage is a needed compromise between efficiency and effectiveness of the test, hence enabling a more regular check of the software under development. We propose a novel approach, namely REDUNET, to reduce a test suite while keeping the same code coverage. We integrate this approach in a complete framework for the automatic generation of efficient and effective test suites, which includes test suite generation, code coverage analysis, and test suite reduction. Our approach formulates the test suite reduction as a set cover problem and applies integer linear programming and a network-based optimisation, which takes advantage of the properties of the control flow graph. We find the optimal set of test cases that keeps the same code coverage in fractions of seconds on real software projects and test suites generated automatically by Randoop. The results on ten real software systems show that the proposed approach finds the optimal minimisation and achieves up to 90% reduction and more than 50% reduction on all systems under analysis. On the largest project our reduction algorithm performs more than three times faster than both integer linear programming alone and the state-of-the-art heuristic Harrold Gupta Soffa.

Author(s):  
Mohammed Akour ◽  
Mamdouh Alenezi

<span>Test suite code coverage is usually used to indicate the capability of a test suite in detecting faults. Earlier research studies, which explored the relationship among test suite effectiveness and code coverage, have not addressed this relationship evolutionally. Moreover, some of these works were studied small or identical domain systems, which make the result generalization process unclear for other systems. Finally, some of these studies were conducted with automatically generated test suites, which might not present the real situation for studied systems, so the results cannot be generalized to real test suites. In this paper, the authors empirically explore three open-source software systems along with their 11 versions. These versions are evolved over time and might have more sources of code and test suites. This work objective is to study the correlation between test suite effectiveness, the size of the test suite, and coverage for three Java programs during their evolution. In this work, the code coverage, test suite LOC and mutation testing coverage are measured to assess the correlation between the effectiveness of fault detection, code coverage, and test suite size. Based on the result we cannot generalize the assumption that test size is always revealing a positive correlation with its effectiveness, but still weak to the high correlation between test effectiveness, test size, and coverage.</span><p> </p>


2019 ◽  
Vol 10 (1) ◽  
pp. 1239-1250
Author(s):  
Abhinandan H Patil

Although several studies have been conducted on regression test selection, augmentation, prioritization, and pruning, regression test suite creation is performed in an ad hoc manner for most software systems by selecting a few crucial parameters and their combinations. Regression test suite creation can be rigorously approached by using the combinatorial testing (CT) method. Although this approach is advantageous, it has been used in only a few cases. This paper presents a practical approach for applying CT and augmenting the Contiki and Cooja base regression test suites with the National Institute of Standards and Technology tools.


Author(s):  
Noureddine Aribi ◽  
Yahia Lebbah

Free and open source software (FOSS) distributions are increasingly based on the abstraction of packages to manage and accommodate new features before and after the deployment stage. However, due to inter-package dependencies, package upgrade entails challenging shortcomings of deployment and management of complex software systems, inhibiting their ability to cope with frequent upgrade failures. Moreover, the upgrade process may be achieved according to some criteria (maximize the stability, minimize outdated packages, etc.). This problem is actually a multi-objective optimization problem. Throughout the article, the authors propose a Leximax approach based on mixed integer linear programming (MILP) to tackle the upgradability problem, while ensuring efficiency and fairness requirements between the objective functions. Experiments performed on real-world instances, from the MANCOOSI project, show that the authors' approach efficiently finds solutions of consistently high quality.


Sign in / Sign up

Export Citation Format

Share Document