2016
Lopez-Herrejon, Roberto E; Ferrer, Javier; Chicano, Francisco; Egyed, Alexander; Alba, Enrique
Evolutionary Computation for Software Product Line Testing: An Overview and Open Challenges Incollection
In: Studies in Computational Intelligence, vol. 617, pp. 59–87, 2016, ISSN: 1860949X.
Abstract | Links | BibTeX | Tags: Feature Models, Feature set, Product line testing, Reverse engineering, search based software engineering, Software Product Lines, Variability modeling
@incollection{Lopez-Herrejon2016,
title = {Evolutionary Computation for Software Product Line Testing: An Overview and Open Challenges},
author = {Roberto E Lopez-Herrejon and Javier Ferrer and Francisco Chicano and Alexander Egyed and Enrique Alba},
url = {http://link.springer.com/10.1007/978-3-319-25964-2_4},
doi = {10.1007/978-3-319-25964-2_4},
issn = {1860949X},
year = {2016},
date = {2016-01-01},
booktitle = {Studies in Computational Intelligence},
volume = {617},
pages = {59--87},
abstract = {textcopyright Springer International Publishing Switzerland 2016. Because of economical, technological and marketing reasons today's software systems are more frequently being built as families where each product variant implements a different combination of features. Software families are commonly called Software Product Lines (SPLs) and over the past three decades have been the subject of extensive research and application. Among the benefits of SPLs are: increased software reuse, faster and easier product customization, and reduced time to market. However, testing SPLs is specially challenging as the number of product variants is usually large making it infeasible to test every single variant. In recent years there has been an increasing interest in applying evolutionary computation techniques for SPL testing. In this chapter, we provide a concise overview of the state of the art and practice in SPL testing with evolutionary techniques as well as to highlight open questions and areas for future research.},
keywords = {Feature Models, Feature set, Product line testing, Reverse engineering, search based software engineering, Software Product Lines, Variability modeling},
pubstate = {published},
tppubtype = {incollection}
}
textcopyright Springer International Publishing Switzerland 2016. Because of economical, technological and marketing reasons today's software systems are more frequently being built as families where each product variant implements a different combination of features. Software families are commonly called Software Product Lines (SPLs) and over the past three decades have been the subject of extensive research and application. Among the benefits of SPLs are: increased software reuse, faster and easier product customization, and reduced time to market. However, testing SPLs is specially challenging as the number of product variants is usually large making it infeasible to test every single variant. In recent years there has been an increasing interest in applying evolutionary computation techniques for SPL testing. In this chapter, we provide a concise overview of the state of the art and practice in SPL testing with evolutionary techniques as well as to highlight open questions and areas for future research.
2015
Ferrer, Javier; Kruse, Peter M; Chicano, Francisco; Alba, Enrique
Search based algorithms for test sequence generation in functional testing Journal Article
In: Information and Software Technology, vol. 58, pp. 419–432, 2015, ISSN: 09505849.
Abstract | Links | BibTeX | Tags: Ant Colony Optimization, Classification Tree Method, functional, Functional testing, Genetic Algorithm, search based software engineering, sequence, Test sequence generation
@article{Ferrer2014,
title = {Search based algorithms for test sequence generation in functional testing},
author = {Javier Ferrer and Peter M Kruse and Francisco Chicano and Enrique Alba},
url = {http://www.sciencedirect.com/science/article/pii/S0950584914001827},
doi = {10.1016/j.infsof.2014.07.014},
issn = {09505849},
year = {2015},
date = {2015-01-01},
journal = {Information and Software Technology},
volume = {58},
pages = {419--432},
abstract = {Context: The generation of dynamic test sequences from a formal specification, complementing traditional testing methods in order to find errors in the source code. Objective: In this paper we extend one specific combinatorial test approach, the Classification Tree Method (CTM), with transition information to generate test sequences. Although we use CTM, this extension is also possible for any combinatorial testing method. Method: The generation of minimal test sequences that fulfill the demanded coverage criteria is an NP-hard problem. Therefore, search-based approaches are required to find such (near) optimal test sequences. Results: The experimental analysis compares the search-based technique with a greedy algorithm on a set of 12 hierarchical concurrent models of programs extracted from the literature. Our proposed search-based approaches (GTSG and ACOts) are able to generate test sequences by finding the shortest valid path to achieve full class (state) and transition coverage. Conclusion: The extended classification tree is useful for generating of test sequences. Moreover, the experimental analysis reveals that our search-based approaches are better than the greedy deterministic approach, especially in the most complex instances. All presented algorithms are actually integrated into a professional tool for functional testing.},
keywords = {Ant Colony Optimization, Classification Tree Method, functional, Functional testing, Genetic Algorithm, search based software engineering, sequence, Test sequence generation},
pubstate = {published},
tppubtype = {article}
}
Context: The generation of dynamic test sequences from a formal specification, complementing traditional testing methods in order to find errors in the source code. Objective: In this paper we extend one specific combinatorial test approach, the Classification Tree Method (CTM), with transition information to generate test sequences. Although we use CTM, this extension is also possible for any combinatorial testing method. Method: The generation of minimal test sequences that fulfill the demanded coverage criteria is an NP-hard problem. Therefore, search-based approaches are required to find such (near) optimal test sequences. Results: The experimental analysis compares the search-based technique with a greedy algorithm on a set of 12 hierarchical concurrent models of programs extracted from the literature. Our proposed search-based approaches (GTSG and ACOts) are able to generate test sequences by finding the shortest valid path to achieve full class (state) and transition coverage. Conclusion: The extended classification tree is useful for generating of test sequences. Moreover, the experimental analysis reveals that our search-based approaches are better than the greedy deterministic approach, especially in the most complex instances. All presented algorithms are actually integrated into a professional tool for functional testing.
2013
Ferrer, Javier; Chicano, Francisco; Alba, Enrique
Estimating software testing complexity Journal Article
In: Information and Software Technology, vol. 55, no. 12, pp. 2125–2139, 2013.
Abstract | Links | BibTeX | Tags: branch coverage, Complexity, Correlations, ES, evolutionary algorithms, evolutionary testing, GA, Markov, search based software engineering, Testability, Validation
@article{Ferrer2013a,
title = {Estimating software testing complexity},
author = {Javier Ferrer and Francisco Chicano and Enrique Alba},
url = {http://www.sciencedirect.com/science/article/pii/S0950584913001535},
year = {2013},
date = {2013-01-01},
journal = {Information and Software Technology},
volume = {55},
number = {12},
pages = {2125--2139},
abstract = {CONTEXT Complexity measures provide us some information about software artifacts. A measure of the difficulty of testing a piece of code could be very useful to take control about the test phase. OBJECTIVE The aim in this paper is the definition of a new measure of the difficulty for a computer to generate test cases, we call it Branch Coverage Expectation (BCE). We also analyze the most common complexity measures and the most important features of a program. With this analysis we are trying to discover whether there exists a relationship between them and the code coverage of an automatically generated test suite. METHOD The definition of this measure is based on a Markov model of the program. This model is used not only to compute the BCE, but also to provide an estimation of the number of test cases needed to reach a given coverage level in the program. In order to check our proposal, we perform a theoretical validation and we carry out an empirical validation study using 2600 test programs. RESULTS The results show that the previously existing measures are not so useful to estimate the difficulty of testing a program, because they are not highly correlated with the code coverage. Our proposed measure is much more correlated with the code coverage than the existing complexity measures. CONCLUSION The high correlation of our measure with the code coverage suggests that the BCE measure is a very promising way of measuring the difficulty to automatically test a program. Our proposed measure is useful for predicting the behavior of an automatic test case generator.},
keywords = {branch coverage, Complexity, Correlations, ES, evolutionary algorithms, evolutionary testing, GA, Markov, search based software engineering, Testability, Validation},
pubstate = {published},
tppubtype = {article}
}
CONTEXT Complexity measures provide us some information about software artifacts. A measure of the difficulty of testing a piece of code could be very useful to take control about the test phase. OBJECTIVE The aim in this paper is the definition of a new measure of the difficulty for a computer to generate test cases, we call it Branch Coverage Expectation (BCE). We also analyze the most common complexity measures and the most important features of a program. With this analysis we are trying to discover whether there exists a relationship between them and the code coverage of an automatically generated test suite. METHOD The definition of this measure is based on a Markov model of the program. This model is used not only to compute the BCE, but also to provide an estimation of the number of test cases needed to reach a given coverage level in the program. In order to check our proposal, we perform a theoretical validation and we carry out an empirical validation study using 2600 test programs. RESULTS The results show that the previously existing measures are not so useful to estimate the difficulty of testing a program, because they are not highly correlated with the code coverage. Our proposed measure is much more correlated with the code coverage than the existing complexity measures. CONCLUSION The high correlation of our measure with the code coverage suggests that the BCE measure is a very promising way of measuring the difficulty to automatically test a program. Our proposed measure is useful for predicting the behavior of an automatic test case generator.
2012
Ferrer, Javier; Kruse, Peter M; Chicano, Francisco; Alba, Enrique
Evolutionary algorithm for prioritized pairwise test data generation Inproceedings
In: Soule, Terence; Moore, Jason H (Ed.): łdots on Genetic and evolutionary łdots, pp. 1213–1220, ACM, New York, New York, USA, 2012, ISBN: 978-1-4503-1177-9.
Abstract | Links | BibTeX | Tags: combinatorial testing, evolutionary algorithm, pair-, pairwise coverage, prioritization, search based soft-, search based software engineering, software testing, Testing Funcional, ware engineering
@inproceedings{DBLP:conf/gecco/FerrerKCA12,
title = {Evolutionary algorithm for prioritized pairwise test data generation},
author = {Javier Ferrer and Peter M Kruse and Francisco Chicano and Enrique Alba},
editor = {Terence Soule and Jason H Moore},
url = {http://dl.acm.org/citation.cfm?id=2330163.2330331 http://dl.acm.org/citation.cfm?doid=2330163.2330331 http://dl.acm.org/citation.cfm?id=2330331},
doi = {10.1145/2330163.2330331},
isbn = {978-1-4503-1177-9},
year = {2012},
date = {2012-07-01},
booktitle = {łdots on Genetic and evolutionary łdots},
pages = {1213--1220},
publisher = {ACM},
address = {New York, New York, USA},
abstract = {Combinatorial Interaction Testing (CIT) is a technique used to discover faults caused by parameter interactions in highly configurable systems. These systems tend to be large and exhaustive testing is generally impractical. Indeed, when the resources are limited, prioritization of test cases is a must. Important test cases are assigned a high priority and should be executed earlier. On the one hand, the prioritization of test cases may reveal faults in early stages of the testing phase. But, on the other hand the generation of minimal test suites that fulfill the demanded coverage criteria is an NP-hard problem. Therefore, search based approaches are required to find the (near) optimal test suites. In this work we present a novel evolutionary algorithm to deal with this problem. The experimental analysis compares five techniques on a set of benchmarks. It reveals that the evolutionary approach is clearly the best in our comparison. The presented algorithm can be integrated into CTE XL professional tool.},
keywords = {combinatorial testing, evolutionary algorithm, pair-, pairwise coverage, prioritization, search based soft-, search based software engineering, software testing, Testing Funcional, ware engineering},
pubstate = {published},
tppubtype = {inproceedings}
}
Combinatorial Interaction Testing (CIT) is a technique used to discover faults caused by parameter interactions in highly configurable systems. These systems tend to be large and exhaustive testing is generally impractical. Indeed, when the resources are limited, prioritization of test cases is a must. Important test cases are assigned a high priority and should be executed earlier. On the one hand, the prioritization of test cases may reveal faults in early stages of the testing phase. But, on the other hand the generation of minimal test suites that fulfill the demanded coverage criteria is an NP-hard problem. Therefore, search based approaches are required to find the (near) optimal test suites. In this work we present a novel evolutionary algorithm to deal with this problem. The experimental analysis compares five techniques on a set of benchmarks. It reveals that the evolutionary approach is clearly the best in our comparison. The presented algorithm can be integrated into CTE XL professional tool.
2009
Ferrer, Javier; Chicano, Francisco; Alba, Enrique
Dealing with inheritance in OO evolutionary testing Inproceedings
In: Genetic and evolutionary computation - GECCO '09, pp. 1665, ACM Press, New York, USA, 2009, ISBN: 9781605583259.
Links | BibTeX | Tags: evolutionary algorithm, instanceof, object-oriented, oo evolutionary testing, search based software engineering, software testing
@inproceedings{Ferrer2009a,
title = {Dealing with inheritance in OO evolutionary testing},
author = {Javier Ferrer and Francisco Chicano and Enrique Alba},
url = {http://dl.acm.org/citation.cfm?id=1569901.1570124},
doi = {10.1145/1569901.1570124},
isbn = {9781605583259},
year = {2009},
date = {2009-07-01},
booktitle = {Genetic and evolutionary computation - GECCO '09},
pages = {1665},
publisher = {ACM Press},
address = {New York, USA},
keywords = {evolutionary algorithm, instanceof, object-oriented, oo evolutionary testing, search based software engineering, software testing},
pubstate = {published},
tppubtype = {inproceedings}
}