@Override public boolean isCovered(ExecutionResult result) { for ( Integer coveredLine : result.getTrace().getCoveredLines()) { if (coveredLine.intValue() == this.line.intValue()) { return true; } } return false; }
private void ensureExecutionResultHasTraces(TestChromosome individual, ExecutionResult result) { if(result.getTraces().isEmpty() && observerClasses.length > 0) { ExecutionResult newResult = runTest(individual.getTestCase()); for(Class<?> observerClass : observerClasses) { OutputTrace<?> trace = newResult.getTrace(observerClass); result.setTrace(trace, observerClass); } } }
protected void handlePredicateCount(ExecutionResult result, Map<Integer, Integer> predicateCount) { for (Entry<Integer, Integer> entry : result.getTrace().getPredicateExecutionCount().entrySet()) { if (!branchesId.contains(entry.getKey()) || (removedBranchesT.contains(entry.getKey()) && removedBranchesF.contains(entry.getKey()))) continue; if (!predicateCount.containsKey(entry.getKey())) predicateCount.put(entry.getKey(), entry.getValue()); else { predicateCount.put(entry.getKey(), predicateCount.get(entry.getKey()) + entry.getValue()); } } }
private void postFitnessDebugInfo(Chromosome individual, ExecutionResult result, double fitness) { if (DEBUG) { if (fitness != 0) { if (PRINT_DEBUG) { System.out.println("goal NOT COVERED. fitness: " + fitness); System.out.println("=============================================================="); } if (DefUseFitnessCalculator.traceCoversGoal(this, individual, result.getTrace())) throw new IllegalStateException( "calculation flawed. goal was covered but fitness was " + fitness); } } }
private double getMethodCallDistance(ExecutionResult result) { String key = branchGoal.getClassName() + "." + branchGoal.getMethodName(); if (!result.getTrace().getMethodContextCount().containsKey(key)) { return Double.MAX_VALUE; } for (Entry<CallContext, Integer> value : result.getTrace().getMethodContextCount().get(key).entrySet()) { if (context.matches(value.getKey())) { return value.getValue() > 0 ? 0.0 : 1.0; } } return Double.MAX_VALUE; }
private double getMethodCallDistance(ExecutionResult result) { String key = branchGoal.getClassName() + "." + branchGoal.getMethodName(); if (!result.getTrace().getMethodContextCount().containsKey(key)) { return Double.MAX_VALUE; } for (Entry<CallContext, Integer> value : result.getTrace().getMethodContextCount().get(key).entrySet()) { if (context.matches(value.getKey())) { return value.getValue() > 0 ? 0.0 : 1.0; } } return Double.MAX_VALUE; }
/** * <p>runSuite</p> * * @param chromosome a {@link org.evosuite.testsuite.TestSuiteChromosome} object. */ public void runSuite(TestSuiteChromosome chromosome) { coveredMethods = new HashSet<String>(); coveredBranchesTrue = new HashSet<Integer>(); coveredBranchesFalse = new HashSet<Integer>(); for (TestCase test : chromosome.getTests()) { ExecutionResult result = runTest(test); coveredMethods.addAll(result.getTrace().getCoveredMethods()); coveredBranchesTrue.addAll(result.getTrace().getCoveredTrueBranches()); coveredBranchesFalse.addAll(result.getTrace().getCoveredFalseBranches()); } }
protected void handleFalseDistances(TestChromosome test, ExecutionResult result, Map<Integer, Double> falseDistance) { for (Entry<Integer, Double> entry : result.getTrace().getFalseDistances().entrySet()) { if(!branchesId.contains(entry.getKey())||!branchCoverageFalseMap.containsKey(entry.getKey())||removedBranchesF.contains(entry.getKey())) continue; if (!falseDistance.containsKey(entry.getKey())) falseDistance.put(entry.getKey(), entry.getValue()); else { falseDistance.put(entry.getKey(), Math.min(falseDistance.get(entry.getKey()), entry.getValue())); } BranchCoverageTestFitness goal = (BranchCoverageTestFitness) this.branchCoverageFalseMap.get(entry.getKey()); assert goal != null; if ((Double.compare(entry.getValue(), 0.0) == 0)) { test.getTestCase().addCoveredGoal(goal); toRemoveBranchesF.add(entry.getKey()); } if(Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(goal, test, entry.getValue()); } } }
protected void handleTrueDistances(TestChromosome test, ExecutionResult result, Map<Integer, Double> trueDistance) { for (Entry<Integer, Double> entry : result.getTrace().getTrueDistances().entrySet()) { if(!branchesId.contains(entry.getKey())||removedBranchesT.contains(entry.getKey())) continue; if (!trueDistance.containsKey(entry.getKey())) trueDistance.put(entry.getKey(), entry.getValue()); else { trueDistance.put(entry.getKey(), Math.min(trueDistance.get(entry.getKey()), entry.getValue())); } BranchCoverageTestFitness goal = (BranchCoverageTestFitness) this.branchCoverageTrueMap.get(entry.getKey()); assert goal != null; if ((Double.compare(entry.getValue(), 0.0) == 0)) { test.getTestCase().addCoveredGoal(goal); toRemoveBranchesT.add(entry.getKey()); } if(Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(goal, test, entry.getValue()); } } }
protected void handleBranchlessMethods(TestChromosome test, ExecutionResult result, Map<String, Integer> callCount) { for (Entry<String, Integer> entry : result.getTrace().getMethodExecutionCount().entrySet()) { if (entry.getKey() == null || !methods.contains(entry.getKey()) || removedRootBranches.contains(entry.getKey())) continue; if (!callCount.containsKey(entry.getKey())) callCount.put(entry.getKey(), entry.getValue()); else { callCount.put(entry.getKey(), callCount.get(entry.getKey()) + entry.getValue()); } // If a specific target method is set we need to check // if this is a target branch or not if (branchlessMethodCoverageMap.containsKey(entry.getKey())) { TestFitnessFunction goal = branchlessMethodCoverageMap.get(entry.getKey()); test.getTestCase().addCoveredGoal(goal); toRemoveRootBranches.add(entry.getKey()); if (Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(goal, test, 0.0); } } } }
/** * Returns the set of predicate indexes whose true branches were covered by * the suite * * @param suite * @return */ private static Set<Integer> getCoveredTrueBranches(TestSuiteChromosome suite) { Set<Integer> covered = new LinkedHashSet<Integer>(); for (TestChromosome testChromosome : suite.getTestChromosomes()) { ExecutionResult lastResult = testChromosome.getLastExecutionResult(); if (lastResult != null) { covered.addAll(lastResult.getTrace().getCoveredTrueBranches()); } } return covered; }
/** * Returns the set of the predicate indexes whose false branch were covered * by the test suite * * @param suite * @return the set of predicate indexes whose false branch were covered */ private static Set<Integer> getCoveredFalseBranches(TestSuiteChromosome suite) { Set<Integer> covered = new LinkedHashSet<Integer>(); for (TestChromosome testChromosome : suite.getTestChromosomes()) { ExecutionResult lastResult = testChromosome.getLastExecutionResult(); if (lastResult != null) { covered.addAll(lastResult.getTrace().getCoveredFalseBranches()); } } return covered; }
private static ControlFlowDistance getRootDistance(ExecutionResult result, String className, String methodName) { ControlFlowDistance d = new ControlFlowDistance(); if(result.getTrace().getCoveredMethods().contains(className + "." + methodName)) { return d; } if(hasConstructorException(result, className, methodName)) { return d; } d.increaseApproachLevel(); return d; }
public double calculateFitnessForObjects() { // select considerable objects Set<Integer> objects = determineConsiderableObjects(goal, result.getTrace()); // calculate minimal fitness over all objects double fitness = 1; for (Integer object : objects) { logger.debug("current object: " + object); if (!hasEntriesForId(result.getTrace().getPassedDefinitions(defVariable), object, goalDefinition.getDefId())) continue; double newFitness = calculateFitnessForObject(object); if (newFitness < fitness) fitness = newFitness; if (fitness == 0.0) return 0.0; } return fitness; }
@Override public void fitnessEvaluation(Chromosome individual) { if(individual instanceof TestSuiteChromosome) { TestSuiteChromosome suite = (TestSuiteChromosome)individual; for(TestChromosome testChromosome : suite.getTestChromosomes()) { ExecutionResult lastResult = testChromosome.getLastExecutionResult(); if(lastResult != null) { for(Integer branchId : lastResult.getTrace().getCoveredTrueBranches()) { if(!coveredTrueBranches.containsKey(branchId)) { coveredTrueBranches.put(branchId, testChromosome.getTestCase()); } } for(Integer branchId : lastResult.getTrace().getCoveredFalseBranches()) { if(!coveredFalseBranches.containsKey(branchId)) { coveredFalseBranches.put(branchId, testChromosome.getTestCase()); } } } } } }
/** * Executes the TestFitnessFunction.getFitness() function on the given * ExecutionResult but using the given targetTrace * * The ExecutionResult is left in it's original state after execution */ private double callTestFitnessFunctionForTrace(ExecutionTrace targetTrace, TestFitnessFunction targetFitness) { ExecutionTrace originalTrace = result.getTrace(); result.setTrace(targetTrace); double fitness = targetFitness.getFitness(individual, result); result.setTrace(originalTrace); return fitness; }
private MutationExecutionResult getMutationResult(ExecutionResult originalResult, ExecutionResult mutationResult) { MutationExecutionResult result = new MutationExecutionResult(); if (TestCoverageGoal.hasTimeout(mutationResult)) { logger.debug("Found timeout in mutant!"); MutationTimeoutStoppingCondition.timeOut(mutation); result.setHasTimeout(true); } if (mutationResult.noThrownExceptions()) { result.setHasException(true); } int numAssertions = getNumAssertions(originalResult, mutationResult); result.setNumAssertions(numAssertions); if (numAssertions == 0) { double impact = getSumDistance(originalResult.getTrace(), mutationResult.getTrace()); result.setImpact(impact); } return result; }
@Override public double getFitness(TestChromosome individual, ExecutionResult result) { double fitness = 0.0; // Get control flow distance if (!result.getTrace().wasMutationTouched(mutation.getId()) || result.calledReflection()) { fitness = 1.0; } else { fitness = normalize(result.getTrace().getMutationDistance(mutation.getId())); logger.debug("Infection distance for mutation = " + fitness); } updateIndividual(this, individual, fitness); if (fitness == 0.0) { individual.getTestCase().addCoveredGoal(this); } if (Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(this, individual, fitness); } return fitness; }
@Override public double getFitness(TestChromosome individual, ExecutionResult result) { double fitness = 0.0; if (branchGoal.getBranch() == null) { fitness = getMethodCallDistance(result); } else if (branchGoal.getValue()) { fitness = getPredicateDistance(result.getTrace().getTrueDistancesContext()); } else { fitness = getPredicateDistance(result.getTrace().getFalseDistancesContext()); } updateIndividual(this, individual, fitness); if (fitness == 0.0) { individual.getTestCase().addCoveredGoal(this); } if (Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(this, individual, fitness); } return fitness; }
@Override public double getFitness(TestChromosome individual, ExecutionResult result) { double fitness = 0.0; if (branchGoal.getBranch() == null) { fitness = getMethodCallDistance(result); } else if (branchGoal.getValue()) { fitness = getPredicateDistance(result.getTrace().getTrueDistancesContext()); } else { fitness = getPredicateDistance(result.getTrace().getFalseDistancesContext()); } updateIndividual(this, individual, fitness); if (fitness == 0.0) { individual.getTestCase().addCoveredGoal(this); } if (Properties.TEST_ARCHIVE) { Archive.getArchiveInstance().updateArchive(this, individual, fitness); } return fitness; }