org.evosuite.testsuite.localsearch.TestSuiteLocalSearchObjective Maven / Gradle / Ivy
/**
* Copyright (C) 2010-2018 Gordon Fraser, Andrea Arcuri and EvoSuite
* contributors
*
* This file is part of EvoSuite.
*
* EvoSuite is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, either version 3.0 of the License, or
* (at your option) any later version.
*
* EvoSuite is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with EvoSuite. If not, see TestSuiteLocalSearchObjective has an internal reference to the whole test suite
* and an index to the position of the test case that is being modified by means of local search.
*
* @author Gordon Fraser
*/
public class TestSuiteLocalSearchObjective implements LocalSearchObjective {
private static final Logger logger = LoggerFactory.getLogger(TestSuiteLocalSearchObjective.class);
private final List fitnessFunctions = new ArrayList<>();
private final TestSuiteChromosome suite;
private final int testIndex;
// TODO: This assumes we are not doing NSGA-II
private boolean isMaximization = false;
private double lastFitnessSum = 0.0;
private Map, Double> lastFitness = new HashMap<>();
private Map, Double> lastCoverage = new HashMap<>();
/**
* Creates a Local Search objective for a TestCase that will be optimized
* using a containing TestSuite to measure the changes in fitness values.
*
* @param fitness
* the list of fitness functions to use to compute the fitness of
* the TestSuiteChromosome
* @param suite
* a TestSuite chromosome that will be subjected to local search
* @param index
* a test index (between 0 and the test suite length) that will
* be used to modify the testchromosome each time a changed has
* been applied.
*/
private TestSuiteLocalSearchObjective(List fitness, TestSuiteChromosome suite,
int index) {
this.fitnessFunctions.addAll(fitness);
this.suite = suite;
this.testIndex = index;
for (TestSuiteFitnessFunction ff : fitness) {
if (ff.isMaximizationFunction())
isMaximization = true;
else
isMaximization = false;
break;
}
updateLastFitness();
updateLastCoverage();
}
/**
* Creates a new TestSuiteLocalSearchObjective for a given list
* of fitness functions, a test suite and a testIndex for
* replacing an optimised test case (i.e. a test case over which was applied
* local search)
*
* @param fitness
* the list of fitness functions to be used on the modified test
* suite
* @param suite
* the original test suite
* @param index
* the index (between 0 and the suite length) that will be
* replaced with a new test case
* @return
*/
public static TestSuiteLocalSearchObjective buildNewTestSuiteLocalSearchObjective(
List> fitness, TestSuiteChromosome suite, int index) {
List ffs = new ArrayList<>();
for (FitnessFunction ff : fitness) {
TestSuiteFitnessFunction tff = (TestSuiteFitnessFunction) ff;
ffs.add(tff);
}
return new TestSuiteLocalSearchObjective(ffs, suite, index);
}
private void updateLastFitness() {
lastFitnessSum = 0.0;
for (TestSuiteFitnessFunction fitness : fitnessFunctions) {
double newFitness = fitness.getFitness(suite);
lastFitnessSum += newFitness;
lastFitness.put(fitness, newFitness);
}
}
private void updateLastCoverage() {
for (TestSuiteFitnessFunction fitness : fitnessFunctions) {
lastCoverage.put(fitness, suite.getCoverage(fitness));
}
}
/**
* Returns true if all the fitness functions are minimising and the fitness
* value for each of them is 0.0
*/
@Override
public boolean isDone() {
for (TestSuiteFitnessFunction fitness : fitnessFunctions) {
if (fitness.isMaximizationFunction() || fitness.getFitness(suite) != 0.0)
return false;
}
return true;
}
/**
* Replaces the test case at position testIndex with the passed
* TestChromosome.
*/
@Override
public boolean hasImproved(TestChromosome testCase) {
return hasChanged(testCase) < 0;
}
/**
* Returns true if by replacing the test case at position
* testIndex with the argument testCase, the
* resulting test suite has not worsened the fitness
*/
@Override
public boolean hasNotWorsened(TestChromosome testCase) {
return hasChanged(testCase) < 1;
}
private boolean isFitnessBetter(double newFitness, double oldFitness) {
if (isMaximization) {
return newFitness > oldFitness;
} else {
return newFitness < oldFitness;
}
}
private boolean isFitnessWorse(double newFitness, double oldFitness) {
if (isMaximization) {
return newFitness < oldFitness;
} else {
return newFitness > oldFitness;
}
}
/**
* Overrides the test case at position testIndex with the
* individual. It returns -1 if the new fitness has improved,
* 1 if the fitness has worsened or 0 if the
* fitness has not changed.
*/
@Override
public int hasChanged(TestChromosome testCase) {
testCase.setChanged(true);
suite.setTestChromosome(testIndex, testCase);
LocalSearchBudget.getInstance().countFitnessEvaluation();
for (TestSuiteFitnessFunction fitnessFunction : fitnessFunctions)
fitnessFunction.getFitness(suite);
double newFitness = suite.getFitness();
if (isFitnessBetter(newFitness, lastFitnessSum)) {
logger.info("Local search improved fitness from " + lastFitnessSum + " to " + newFitness);
updateLastFitness();
updateLastCoverage();
return -1;
} else if (isFitnessWorse(newFitness, lastFitnessSum)) {
logger.info("Local search worsened fitness from " + lastFitnessSum + " to " + newFitness);
suite.setFitnessValues(lastFitness);
suite.setCoverageValues(lastCoverage);
return 1;
} else {
logger.info("Local search did not change fitness of " + lastFitnessSum);
updateLastCoverage();
return 0;
}
}
/**
* Since the fitness is computed by the underlying test suite associated to
* this local search objective, this function should not belong. TODO: Why
* not simply returning the fitness functions of the suite?
*/
@Override
public List> getFitnessFunctions() {
throw new NotImplementedException("This should not be called");
}
/**
* Since the fitness is governed by the underlying suite associated to this
* goal, this function should never be invoked.
*/
@Override
public void addFitnessFunction(FitnessFunction fitness) {
throw new NotImplementedException("This should not be called");
}
@Override
public boolean isMaximizationObjective() {
return isMaximization;
}
}