Author: Kevin Jalbert (firstname.lastname@example.org)
Copyright: Copyright (c) 2011 Kevin Jalbert
License: MIT License
The mutation score predictor is a technique that allows one to predict the mutation score of methods and classes within a Java project. The benefit of predicting the mutation score is that one does not need to actually execute the mutation testing process. Mutation testing is a costly procedure as it requires multiple executions of the test suite. By predicting with a reasonable level of accuracy the mutation score of methods and classes mutation scores can be acquire with relatively low resource consumption.
Some quick background material on mutation testing, support vector machines and software metrics are supplied in the following sections.
Mutation testing is a technique that evaluates the coverage achieved by a unit test suite for a project. The objective of mutation testing is to identify weak areas in the unit test suite, this is accomplished by seeding faults into the project. A mutant is a copy of the project except for a newly introduce fault, as a result of a single change. If a mutant is detected by the test suite then is was killed, otherwise it was undetected. A mutation score is given at the ending of the mutation testing process that quantifies the test suites ability to kill mutants (given as a percent of killed mutants).
The selected mutation testing tool is Javalanche.
Support Vector Machine
Support vector machine is a machine learning technique that falls under the category of supervised learning algorithms. This technique is capable of learning on a set of features dictate the category of a data item, essentially it is a classifier. Supervised learning algorithms will first be trained on known data (features and categories are known), and then are used on the test data (only features known). The classifier will attempt to correctly classify the unknown data given a model that was created during the training phase.
The selected support vector machine tool is LIBSVM.
Software metrics are measurements of software artifact attributes. These attributes commonly characterize structural properties such as size and complexity. Our approach uses source code and test suite metrics as these two software artifacts are components of the mutation testing process. We gather a set of source code metrics for both the system under test and the test suite. We further collect the test suite's coverage over the system under test.
The selected source code metric tool is the Eclipse Metrics Plugin.
The selected test suite coverage metric tool is EMMA.
This project requires multiple languages and tools to function as intended. The list of requirements are displayed below, as well as the method to execute this project as intended. To aid the user in executing the method, a Rakefile exists with the project to automate some of the steps.
The following list enumerates the requirements for this project. The project was developed on Linux and uses some Linux-only features.
- Eclipse Metric Plugin
- Maven (Optional, only if working with a project that uses Maven)
- Import project into Eclipse (consider looking at Selecting a Project)
- Enable the metrics reporting (within the project's properties in Eclipse)
- Run the rake task 'install' to install the necessary components
- Run the rake task 'setup_svm' to build up the support vector machine
- Run the rake task 'cross_validation' to test the cross validation accuracy
See the Usage page in the Wiki for detailed explaination of the the various commands provided in the mutation_score_predictor.