private double getSumDistance(ExecutionTrace orig_trace, ExecutionTrace mutant_trace) { // TODO: Also sum up differences in branch distances as part of impact! // double sum = getCoverageDifference(getCoverage(orig_trace), // getCoverage(mutant_trace)); logger.debug("Calculating coverage impact"); double coverage_impact = getCoverageDifference(orig_trace.getCoverageData(), mutant_trace.getCoverageData()); logger.debug("Coverage impact: " + coverage_impact); logger.debug("Calculating data impact"); double data_impact = getCoverageDifference(orig_trace.getReturnData(), mutant_trace.getReturnData()); logger.debug("Data impact: " + data_impact); double branch_impact = 0.0; for (Integer predicate : orig_trace.getCoveredPredicates()) { if (mutant_trace.hasTrueDistance(predicate)) { branch_impact += normalize(Math.abs(orig_trace.getTrueDistance(predicate) - mutant_trace.getTrueDistance(predicate))); } else { branch_impact += 1.0; } if (mutant_trace.hasFalseDistance(predicate)) { branch_impact += normalize(Math.abs(orig_trace.getFalseDistance(predicate) - mutant_trace.getFalseDistance(predicate))); } else { branch_impact += 1.0; } } logger.debug("Branch impact: " + branch_impact); return normalize(coverage_impact) + normalize(data_impact) + branch_impact; }
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()); } } }
@Override public double getDistance(TestChromosome individual1, TestChromosome individual2) { ExecutionResult result1 = getExecutionResult(individual1); ExecutionResult result2 = getExecutionResult(individual2); ExecutionTrace trace1 = result1.getTrace(); ExecutionTrace trace2 = result2.getTrace(); double difference = 0.0; for(Integer branch : branches) { if(trace1.hasTrueDistance(branch) && trace2.hasTrueDistance(branch)) { double distance1 = trace1.getTrueDistance(branch); double distance2 = trace2.getTrueDistance(branch); difference += Math.abs(distance1 - distance2); } else if(trace1.hasTrueDistance(branch) || trace2.hasTrueDistance(branch)) { difference += 1.0; } } Set<String> methods1 = trace1.getCoveredBranchlessMethods(); Set<String> methods2 = trace2.getCoveredBranchlessMethods(); for(String branchlessMethod : branchlessMethods) { if(methods1.contains(branchlessMethod) != methods2.contains(branchlessMethod)) { difference += 1.0; } } difference /= (branches.size() + branchlessMethods.size()); return difference; }
@Ignore @Test public void testLesserEqual() { final Integer branchId = 3; final String methodName = "lesserEqual_IF_CMPGT"; ExecutionTrace execTrace = execute(methodName, 5, 5); Assert.assertEquals(methodName + signature, BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId).getMethodName()); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(1.0, execTrace.getFalseDistance(branchId), DELTA); execTrace = execute(methodName, 6, 5); Assert.assertEquals(1.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(0.0, execTrace.getFalseDistance(branchId), DELTA); execTrace = execute(methodName, 5, 6); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(2.0, execTrace.getFalseDistance(branchId), DELTA); }
continue; for (Entry<Integer, Integer> entry : result.getTrace().getPredicateExecutionCount().entrySet()) { if (!predicateCount.containsKey(entry.getKey())) predicateCount.put(entry.getKey(), entry.getValue()); for (Entry<Integer, Double> entry : result.getTrace().getTrueDistances().entrySet()) { if (!trueDistance.containsKey(entry.getKey())) trueDistance.put(entry.getKey(), entry.getValue()); for (Entry<Integer, Double> entry : result.getTrace().getFalseDistances().entrySet()) { if (!falseDistance.containsKey(entry.getKey())) falseDistance.put(entry.getKey(), entry.getValue());
@Ignore @Test public void testDependingInstrumentation() throws Exception { Class<?> originalClass = DependentClassLoaderTestSubject.class; Properties.TARGET_CLASS = originalClass.getName(); Properties.PROJECT_PREFIX = originalClass.getPackage().getName(); Properties.TARGET_CLASS_PREFIX = Properties.PROJECT_PREFIX; TestabilityTransformationClassLoader instrumentingClassLoader = new TestabilityTransformationClassLoader(); Class<?> changedClass = instrumentingClassLoader.loadClass(ClassLoaderTestSubject.class.getName()); Assert.assertEquals(instrumentingClassLoader, changedClass.getClassLoader()); Object changed = changedClass.getConstructor().newInstance(); ExecutionTracer.enable(); ExecutionTracer.getExecutionTracer().clear(); TestUtil.invokeMethod(changed, "trySomethingElse"); ExecutionTrace execTrace = ExecutionTracer.getExecutionTracer().getTrace(); execTrace = ExecutionTracer.getExecutionTracer().getTrace(); Assert.assertFalse(execTrace.getTrueDistances().isEmpty()); Assert.assertFalse(execTrace.getFalseDistances().isEmpty()); ExecutionTracer.getExecutionTracer().clear(); }
/** * Called by the instrumented code each time an unconditional branch is * taken. This is not enabled by default, only some coverage criteria (e.g., * LCSAJ) use it. * * @param opcode * a int. * @param branch * a int. * @param bytecode_id * a int. */ public static void passedUnconditionalBranch(int opcode, int branch, int bytecode_id) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; // Add current branch to control trace tracer.trace.branchPassed(branch, bytecode_id, 0.0, 0.0); }
/** * Return trace of current execution * * @return a {@link org.evosuite.testcase.execution.ExecutionTrace} object. */ public ExecutionTrace getTrace() { trace.finishCalls(); return trace; // ExecutionTrace copy = trace.clone(); // // copy.finishCalls(); // return copy; }
/** * This method is added in the transformed bytecode * * @param className */ public static void exitClassInit(String className) { final String classNameWithDots = className.replace('/', '.'); ExecutionTracer tracer = getExecutionTracer(); // if (tracer.disabled) // return; // // if (isThreadNeqCurrentThread()) // return; // // checkTimeout(); tracer.trace.classInitialized(classNameWithDots); }
/** * Called by instrumented code each time a variable gets written to (a * Definition) * * @param caller * a {@link java.lang.Object} object. * @param defID * a int. */ public static void passedDefinition(Object object, Object caller, int defID) { if (isThreadNeqCurrentThread()) return; ExecutionTracer tracer = getExecutionTracer(); if (!tracer.disabled) tracer.trace.definitionPassed(object, caller, defID); }
/** * Called by instrumented code whenever a method is left * * @param classname * a {@link java.lang.String} object. * @param methodname * a {@link java.lang.String} object. */ public static void leftMethod(String classname, String methodname) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; tracer.trace.exitMethod(classname, methodname); // logger.trace("Left method " + classname + "." + methodname); }
/** * Called by instrumented code whenever a new method is called * * @param classname * a {@link java.lang.String} object. * @param methodname * a {@link java.lang.String} object. * @param caller * a {@link java.lang.Object} object. * @throws org.evosuite.testcase.execution.TestCaseExecutor$TimeoutExceeded * if any. */ public static void enteredMethod(String classname, String methodname, Object caller) throws TestCaseExecutor.TimeoutExceeded { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); //logger.trace("Entering method " + classname + "." + methodname); tracer.trace.enteredMethod(classname, methodname, caller); }
@Ignore @Test public void testLesserThan() { final Integer branchId = 4; final String methodName = "lesserThan_IF_CMPGE"; ExecutionTrace execTrace = execute(methodName, 5, 5); Assert.assertEquals(methodName + signature, BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId).getMethodName()); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), 1.0); Assert.assertEquals(0.0, execTrace.getFalseDistance(branchId), 0.0); execTrace = execute(methodName, 5, 6); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), 0.0); Assert.assertEquals(0.0, execTrace.getFalseDistance(branchId), 1.0); }
test.setChanged(false); for (Entry<Integer, Integer> entry : result.getTrace().getPredicateExecutionCount().entrySet()) { if (!branchesId.contains(entry.getKey()) || (removedBranchesT.contains(entry.getKey()) for (Entry<Integer, Double> entry : result.getTrace().getTrueDistances().entrySet()) { if(!branchesId.contains(entry.getKey())||removedBranchesT.contains(entry.getKey())) continue; if (!trueDistance.containsKey(entry.getKey())) for (Entry<Integer, Double> entry : result.getTrace().getFalseDistances().entrySet()) { if(!branchesId.contains(entry.getKey())||removedBranchesF.contains(entry.getKey())) continue; if (!falseDistance.containsKey(entry.getKey()))
original.assess(6); ExecutionTrace execTrace = ExecutionTracer.getExecutionTracer().getTrace(); Assert.assertTrue(execTrace.getTrueDistances().isEmpty()); Assert.assertTrue(execTrace.getFalseDistances().isEmpty()); TestUtil.invokeMethod(changed, "assess", Integer.valueOf(6)); execTrace = ExecutionTracer.getExecutionTracer().getTrace(); Assert.assertFalse(execTrace.getTrueDistances().isEmpty()); Assert.assertFalse(execTrace.getFalseDistances().isEmpty()); ExecutionTracer.getExecutionTracer().clear();
tracer.trace.branchPassed(branch, bytecode_id, distance_true, distance_false);
@Ignore @Test public void testGreaterThan() { final Integer branchId = 2; final String methodName = "greaterThan_IF_CMPLE"; ExecutionTrace execTrace = execute(methodName, 5, 5); Assert.assertEquals(methodName + signature, BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId).getMethodName()); Assert.assertEquals(1.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(0.0, execTrace.getFalseDistance(branchId), DELTA); execTrace = execute(methodName, 6, 5); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(1.0, execTrace.getFalseDistance(branchId), DELTA); }
tracer.trace.branchPassed(branch, bytecode_id, distance_true, distance_false);
@Ignore @Test public void testGreaterEqual() { final Integer branchId = 1; final String methodName = "greaterEqual_IF_CMPLT"; ExecutionTrace execTrace = execute(methodName, 5, 5); Assert.assertEquals(methodName + signature, BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId).getMethodName()); Assert.assertEquals(0.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(1.0, execTrace.getFalseDistance(branchId), DELTA); execTrace = execute(methodName, 5, 6); Assert.assertEquals(1.0, execTrace.getTrueDistance(branchId), DELTA); Assert.assertEquals(0.0, execTrace.getFalseDistance(branchId), DELTA); }