Examples with ExecutionResult org.evosuite.testcase.ExecutionResult used on opensource projects

Example 1 with ExecutionResult

use of org.evosuite.testcase.ExecutionResult in project evosuite by EvoSuite.

the class SearchStatistics method minimized.

/**
 * {@inheritDoc}
 */
@Override
public void minimized(Chromosome chromosome) {
    TestSuiteChromosome best = (TestSuiteChromosome) chromosome;
    StatisticEntry entry = statistics.get(statistics.size() - 1);
    entry.tests = best.getTests();
    // TODO: Remember which lines were covered
    // This information is in ExecutionTrace.coverage
    entry.size_minimized = best.size();
    entry.length_minimized = best.totalLengthOfTestCases();
    entry.minimized_time = System.currentTimeMillis();
    entry.coverage = new HashSet<Integer>();
    entry.coveredIntraMethodPairs = 0;
    entry.coveredInterMethodPairs = 0;
    entry.coveredIntraClassPairs = 0;
    entry.coveredParameterPairs = 0;
    entry.aliasingIntraMethodPairs = 0;
    entry.aliasingInterMethodPairs = 0;
    entry.aliasingIntraClassPairs = 0;
    entry.aliasingParameterPairs = 0;
    entry.coveredAliasIntraMethodPairs = 0;
    entry.coveredAliasInterMethodPairs = 0;
    entry.coveredAliasIntraClassPairs = 0;
    entry.coveredAliasParameterPairs = 0;
    // TODO isn't this more or less copy-paste of
    // BranchCoverageSuiteFitness.getFitness()?
    // DONE To make this work for other criteria too, it would be perfect if
    // one
    // could ask every suite fitness how many goals were covered
    logger.debug("Calculating coverage of best individual with fitness " + chromosome.getFitness());
    Map<Integer, Double> true_distance = new HashMap<Integer, Double>();
    Map<Integer, Double> false_distance = new HashMap<Integer, Double>();
    Map<Integer, Integer> predicate_count = new HashMap<Integer, Integer>();
    Set<String> covered_methods = new HashSet<String>();
    Map<String, Set<Class<?>>> implicitTypesOfExceptions = new HashMap<String, Set<Class<?>>>();
    Map<String, Set<Class<?>>> explicitTypesOfExceptions = new HashMap<String, Set<Class<?>>>();
    Map<TestCase, Map<Integer, Boolean>> isExceptionExplicit = new HashMap<TestCase, Map<Integer, Boolean>>();
    Set<DefUseCoverageTestFitness> coveredDUGoals = new HashSet<DefUseCoverageTestFitness>();
    if (ArrayUtil.contains(Properties.CRITERION, Properties.Criterion.DEFUSE) || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE")) {
        for (DefUseCoverageTestFitness goal : DefUseCoverageFactory.getDUGoals()) {
            if (goal.isInterMethodPair())
                entry.numInterMethodPairs++;
            else if (goal.isIntraClassPair())
                entry.numIntraClassPairs++;
            else if (goal.isParameterGoal())
                entry.numParameterPairs++;
            else
                entry.numIntraMethodPairs++;
            if (goal.isAlias()) {
                if (goal.isInterMethodPair())
                    entry.aliasingInterMethodPairs++;
                else if (goal.isIntraClassPair())
                    entry.aliasingIntraClassPairs++;
                else if (goal.isParameterGoal())
                    entry.aliasingParameterPairs++;
                else
                    entry.aliasingIntraMethodPairs++;
            }
        }
        entry.numDefinitions = DefUsePool.getDefCounter();
        entry.numUses = DefUsePool.getUseCounter();
        entry.numDefUsePairs = DefUseCoverageFactory.getDUGoals().size();
    }
    logger.debug("Calculating line coverage");
    for (TestChromosome test : best.tests) {
        ExecutionResult result = executeTest(test, entry.className);
        ExecutionTrace trace = result.getTrace();
        entry.coverage.addAll(getCoveredLines(trace, entry.className));
        isExceptionExplicit.put(test.getTestCase(), result.explicitExceptions);
        if (ArrayUtil.contains(Properties.CRITERION, Properties.Criterion.DEFUSE) || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE")) {
            for (DefUseCoverageTestFitness goal : DefUseCoverageFactory.getDUGoals()) {
                if (coveredDUGoals.contains(goal))
                    continue;
                if (goal.isCovered(result)) {
                    coveredDUGoals.add(goal);
                    if (goal.isInterMethodPair()) {
                        entry.coveredInterMethodPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasInterMethodPairs++;
                        }
                    } else if (goal.isIntraClassPair()) {
                        entry.coveredIntraClassPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasIntraClassPairs++;
                        }
                    } else if (goal.isParameterGoal()) {
                        entry.coveredParameterPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasParameterPairs++;
                        }
                    } else {
                        entry.coveredIntraMethodPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasIntraMethodPairs++;
                        }
                    }
                }
            }
        }
        for (String method : trace.getCoveredMethods()) {
            if (method.startsWith(Properties.TARGET_CLASS) || method.startsWith(Properties.TARGET_CLASS + '$'))
                covered_methods.add(method);
        }
        for (Entry<Integer, Double> e : trace.getTrueDistances().entrySet()) {
            if (!predicate_count.containsKey(e.getKey()))
                predicate_count.put(e.getKey(), 1);
            else
                predicate_count.put(e.getKey(), predicate_count.get(e.getKey()) + 1);
            if (!true_distance.containsKey(e.getKey()) || true_distance.get(e.getKey()) > e.getValue()) {
                true_distance.put(e.getKey(), e.getValue());
            }
        }
        for (Entry<Integer, Double> e : trace.getFalseDistances().entrySet()) {
            if (!predicate_count.containsKey(e.getKey()))
                predicate_count.put(e.getKey(), 1);
            else
                predicate_count.put(e.getKey(), predicate_count.get(e.getKey()) + 1);
            if (!false_distance.containsKey(e.getKey()) || false_distance.get(e.getKey()) > e.getValue()) {
                false_distance.put(e.getKey(), e.getValue());
            }
        }
    }
    for (TestCase test : entry.results.keySet()) {
        Map<Integer, Throwable> exceptions = entry.results.get(test);
        // iterate on the indexes of the statements that resulted in an exception
        for (Integer i : exceptions.keySet()) {
            Throwable t = exceptions.get(i);
            if (t instanceof SecurityException && Properties.SANDBOX)
                continue;
            if (i >= test.size()) {
                // Timeouts are put after the last statement if the process was forcefully killed
                continue;
            }
            String methodName = "";
            boolean sutException = false;
            if (test.getStatement(i) instanceof MethodStatement) {
                MethodStatement ms = (MethodStatement) test.getStatement(i);
                Method method = ms.getMethod().getMethod();
                methodName = method.getName() + Type.getMethodDescriptor(method);
                if (method.getDeclaringClass().equals(Properties.getTargetClass()))
                    sutException = true;
            } else if (test.getStatement(i) instanceof ConstructorStatement) {
                ConstructorStatement cs = (ConstructorStatement) test.getStatement(i);
                Constructor<?> constructor = cs.getConstructor().getConstructor();
                methodName = "<init>" + Type.getConstructorDescriptor(constructor);
                if (constructor.getDeclaringClass().equals(Properties.getTargetClass()))
                    sutException = true;
            }
            boolean notDeclared = !test.getStatement(i).getDeclaredExceptions().contains(t.getClass());
            if (notDeclared && sutException) {
                /*
					 * we need to distinguish whether it is explicit (ie "throw" in the code, eg for validating
					 * input for pre-condition) or implicit ("likely" a real fault).
					 */
                /*
					 * FIXME: need to find a way to calculate it
					 */
                boolean isExplicit = isExceptionExplicit.get(test).containsKey(i) && isExceptionExplicit.get(test).get(i);
                if (isExplicit) {
                    if (!explicitTypesOfExceptions.containsKey(methodName))
                        explicitTypesOfExceptions.put(methodName, new HashSet<Class<?>>());
                    explicitTypesOfExceptions.get(methodName).add(t.getClass());
                } else {
                    if (!implicitTypesOfExceptions.containsKey(methodName))
                        implicitTypesOfExceptions.put(methodName, new HashSet<Class<?>>());
                    implicitTypesOfExceptions.get(methodName).add(t.getClass());
                }
            }
        }
    }
    int num_covered = 0;
    entry.error_branches = BranchPool.getNumArtificialBranches();
    for (Integer key : predicate_count.keySet()) {
        // logger.info("Key: "+key);
        double df = true_distance.get(key);
        double dt = false_distance.get(key);
        Branch b = BranchPool.getBranch(key);
        if (!b.getClassName().startsWith(Properties.TARGET_CLASS) && !b.getClassName().startsWith(Properties.TARGET_CLASS + '$'))
            continue;
        // if (!b.isInstrumented()) {
        if (df == 0.0)
            num_covered++;
        if (dt == 0.0)
            num_covered++;
        // }
        if (b.isInstrumented()) {
            // entry.error_branches++;
            if (df == 0.0)
                entry.error_branches_covered++;
            if (dt == 0.0)
                entry.error_branches_covered++;
        }
    }
    for (String methodName : CFGMethodAdapter.getMethodsPrefix(Properties.TARGET_CLASS)) {
        boolean allArtificial = true;
        int splitPoint = methodName.lastIndexOf(".");
        String cName = methodName.substring(0, splitPoint);
        String mName = methodName.substring(splitPoint + 1);
        boolean hasBranches = false;
        for (Branch b : BranchPool.retrieveBranchesInMethod(cName, mName)) {
            hasBranches = true;
            if (!b.isInstrumented()) {
                allArtificial = false;
                break;
            }
        }
        if (hasBranches && allArtificial) {
            entry.error_branchless_methods++;
            if (covered_methods.contains(methodName)) {
                entry.error_branchless_methods_covered++;
            }
        }
    }
    int coveredBranchlessMethods = 0;
    for (String branchlessMethod : BranchPool.getBranchlessMethodsMemberClasses(Properties.TARGET_CLASS)) {
        if (covered_methods.contains(branchlessMethod))
            coveredBranchlessMethods++;
    }
    // + covered branchless methods?
    entry.covered_branches = num_covered;
    entry.covered_methods = covered_methods.size();
    entry.covered_branchless_methods = coveredBranchlessMethods;
    // BranchCoverageSuiteFitness f = new BranchCoverageSuiteFitness();
    /*
		if (Properties.CRITERION == Properties.Criterion.DEFUSE
		        || Properties.ANALYSIS_CRITERIA.contains("DefUse")) {
			entry.coveredIntraMethodPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTRA_METHOD);
			entry.coveredInterMethodPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTER_METHOD);
			entry.coveredIntraClassPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTRA_CLASS);
			entry.coveredParameterPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.PARAMETER);
		}
			*/
    // System.out.println(covered_methods);
    // DONE make this work for other criteria too. this will only work for
    // branch coverage - see searchStarted()/Finished()
    // entry.total_goals = 2 * entry.total_branches +
    // entry.branchless_methods; - moved to searchStarted()
    // entry.covered_goals = num_covered; - moved to searchFinished()
    // for(String e : CFGMethodAdapter.branchless_methods) {
    // for (String e : CFGMethodAdapter.methods) {
    // for (String e : BranchPool.getBranchlessMethods()) {
    // if (covered_methods.contains(e)) {
    // logger.info("Covered method: " + e);
    // entry.covered_goals++;
    // } else {
    // logger.info("Method is not covered: " + e);
    // }
    /*
		 * logger.debug("Covered methods: " + covered_methods.size() + "/" +
		 * entry.total_methods); for (String method : covered_methods) {
		 * logger.debug("Covered method: " + method); }
		 */
    // }
    String s = calculateCoveredBranchesBitString(best);
    entry.goalCoverage = s;
    entry.explicitMethodExceptions = getNumExceptions(explicitTypesOfExceptions);
    entry.explicitTypeExceptions = getNumClassExceptions(explicitTypesOfExceptions);
    entry.implicitMethodExceptions = getNumExceptions(implicitTypesOfExceptions);
    entry.implicitTypeExceptions = getNumClassExceptions(implicitTypesOfExceptions);
    entry.implicitExceptions = implicitTypesOfExceptions;
    entry.explicitExceptions = explicitTypesOfExceptions;
}

Example 2 with ExecutionResult

use of org.evosuite.testcase.ExecutionResult in project evosuite by EvoSuite.

the class PrimePathSuiteFitness method getFitness.

/* (non-Javadoc)
	 * @see org.evosuite.ga.FitnessFunction#getFitness(org.evosuite.ga.Chromosome)
	 */
/**
 * {@inheritDoc}
 */
@Override
public double getFitness(AbstractTestSuiteChromosome<? extends ExecutableChromosome> suite) {
    List<ExecutionResult> results = runTestSuite(suite);
    List<TestFitnessFunction> coveredGoals = new ArrayList<TestFitnessFunction>();
    double fitness = 0.0;
    for (TestFitnessFunction goal : goals) {
        double goalFitness = Double.MAX_VALUE;
        for (ExecutionResult result : results) {
            TestChromosome tc = new TestChromosome();
            tc.setTestCase(result.test);
            double resultFitness = goal.getFitness(tc, result);
            if (resultFitness < goalFitness)
                goalFitness = resultFitness;
            if (goalFitness == 0.0) {
                result.test.addCoveredGoal(goal);
                coveredGoals.add(goal);
                break;
            }
        }
        fitness += goalFitness;
    }
    suite.setCoverage(this, coveredGoals.size() / (double) goals.size());
    updateIndividual(this, suite, fitness);
    return fitness;
}

Example 3 with ExecutionResult

use of org.evosuite.testcase.ExecutionResult in project evosuite by EvoSuite.

the class LCSAJCoverageSuiteFitness method getFitness.

/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.evosuite.ga.FitnessFunction#getFitness(org.
	 * evosuite.ga.Chromosome)
	 */
/**
 * {@inheritDoc}
 */
@Override
public double getFitness(AbstractTestSuiteChromosome<? extends ExecutableChromosome> suite) {
    List<ExecutionResult> results = runTestSuite(suite);
    double fitness = branchFitness.getFitness(suite);
    logger.debug("Branch fitness: {}", fitness);
    // Map<String, Integer> call_count = new HashMap<String, Integer>();
    HashMap<Integer, Integer> trueExecutions = new HashMap<Integer, Integer>();
    HashMap<Integer, Integer> falseExecutions = new HashMap<Integer, Integer>();
    HashMap<LCSAJ, Double> LCSAJFitnesses = new HashMap<LCSAJ, Double>();
    logger.debug("Checking " + LCSAJFitnessFunctions.size() + " LCSAJs against " + results.size() + " tests = " + LCSAJFitnessFunctions.size() * results.size() + " test/LCSAJ combinations");
    for (ExecutionResult result : results) {
        for (LCSAJCoverageTestFitness testFitness : LCSAJFitnessFunctions) {
            TestChromosome chromosome = new TestChromosome();
            chromosome.setTestCase(result.test);
            chromosome.setLastExecutionResult(result);
            double newFitness = testFitness.getFitness(chromosome, result);
            if (!LCSAJFitnesses.containsKey(testFitness.lcsaj))
                LCSAJFitnesses.put(testFitness.lcsaj, newFitness);
            else {
                double oldFitness = LCSAJFitnesses.get(testFitness.lcsaj);
                if (newFitness < oldFitness)
                    LCSAJFitnesses.put(testFitness.lcsaj, newFitness);
            }
        }
        for (Entry<Integer, Integer> entry : result.getTrace().getPredicateExecutionCount().entrySet()) {
            if (!trueExecutions.containsKey(entry.getKey()))
                trueExecutions.put(entry.getKey(), entry.getValue());
            else {
                trueExecutions.put(entry.getKey(), trueExecutions.get(entry.getKey()) + entry.getValue());
            }
            if (!falseExecutions.containsKey(entry.getKey()))
                falseExecutions.put(entry.getKey(), entry.getValue());
            else {
                falseExecutions.put(entry.getKey(), falseExecutions.get(entry.getKey()) + entry.getValue());
            }
        }
    }
    for (LCSAJ l : LCSAJFitnesses.keySet()) {
        fitness += normalize(LCSAJFitnesses.get(l));
    }
    fitness += branchFitness.getFitness(suite);
    logger.debug("Combined fitness: " + fitness);
    double missingBranches = 0.0;
    for (Integer executedID : expectedTrueExecutions.keySet()) {
        if (!trueExecutions.containsKey(executedID))
            missingBranches += expectedTrueExecutions.get(executedID);
        else {
            if (trueExecutions.get(executedID) < expectedTrueExecutions.get(executedID))
                missingBranches += expectedTrueExecutions.get(executedID) - trueExecutions.get(executedID);
        }
    }
    for (Integer executedID : expectedFalseExecutions.keySet()) {
        if (!falseExecutions.containsKey(executedID))
            missingBranches += expectedFalseExecutions.get(executedID);
        else {
            if (falseExecutions.get(executedID) < expectedFalseExecutions.get(executedID))
                missingBranches += expectedFalseExecutions.get(executedID) - falseExecutions.get(executedID);
        }
    }
    fitness += normalize(missingBranches);
    logger.info("Combined fitness with correction: " + fitness);
    updateIndividual(this, suite, fitness);
    double coverage = 0.0;
    for (LCSAJ l : LCSAJFitnesses.keySet()) {
        if (LCSAJFitnesses.get(l) == 0)
            coverage += 1;
    }
    suite.setCoverage(this, coverage / LCSAJFitnesses.size());
    return fitness;
}

Example 4 with ExecutionResult

use of org.evosuite.testcase.ExecutionResult in project evosuite by EvoSuite.

the class ReportGenerator method executeTest.

/**
 * <p>
 * executeTest
 * </p>
 *
 * @param testChromosome
 *            a {@link org.evosuite.testcase.TestChromosome} object.
 * @param className
 *            a {@link java.lang.String} object.
 * @return a {@link org.evosuite.testcase.ExecutionResult} object.
 */
public ExecutionResult executeTest(TestChromosome testChromosome, String className) {
    ExecutionResult result = testChromosome.getLastExecutionResult();
    if (result == null || testChromosome.isChanged()) {
        try {
            if (logger.isTraceEnabled()) {
                logger.trace(testChromosome.getTestCase().toCode());
            }
            TestCaseExecutor executor = TestCaseExecutor.getInstance();
            result = executor.execute(testChromosome.getTestCase());
        } catch (Exception e) {
            logger.error("TG: Exception caught: " + e.getMessage(), e);
            try {
                Thread.sleep(1000);
                result.setTrace(ExecutionTracer.getExecutionTracer().getTrace());
            } catch (Exception e1) {
                logger.error("Cannot set trace in test case with exception. Going to kill client", e1);
                throw new Error(e1);
            }
        }
    }
    StatisticEntry entry = statistics.get(statistics.size() - 1);
    entry.results.put(testChromosome.getTestCase(), result.getCopyOfExceptionMapping());
    return result;
}