/** * Execute a test case on the original unit * * @param test * The test case that should be executed * @return a {@link org.evosuite.testcase.execution.ExecutionResult} object. */ protected ExecutionResult runTest(TestCase test) { ExecutionResult result = new ExecutionResult(test); try { logger.debug("Executing test"); result = TestCaseExecutor.getInstance().execute(test); int num = test.size(); MaxStatementsStoppingCondition.statementsExecuted(num); result.setTrace(comparisonObserver.getTrace(), ComparisonTraceEntry.class); result.setTrace(primitiveObserver.getTrace(), PrimitiveTraceEntry.class); result.setTrace(inspectorObserver.getTrace(), InspectorTraceEntry.class); result.setTrace(fieldObserver.getTrace(), PrimitiveFieldTraceEntry.class); result.setTrace(nullObserver.getTrace(), NullTraceEntry.class); result.setTrace(sameObserver.getTrace(), SameTraceEntry.class); if(!Properties.isRegression()) result.setTrace(arrayObserver.getTrace(), ArrayTraceEntry.class); result.setTrace(arrayLengthObserver.getTrace(), ArrayLengthTraceEntry.class); result.setTrace(containsTraceObserver.getTrace(), ContainsTraceEntry.class); } catch (Exception e) { throw new Error(e); } return result; }
/** {@inheritDoc} */ @Override public void copyCachedResults(ExecutableChromosome other) { if (test == null) throw new RuntimeException("Test is null!"); if (other.lastExecutionResult != null) { this.lastExecutionResult = other.lastExecutionResult.clone(); this.lastExecutionResult.setTest(this.test); } if (other.lastMutationResult != null) { for (Mutation mutation : other.lastMutationResult.keySet()) { MutationExecutionResult copy = other.lastMutationResult.get(mutation); //.clone(); //copy.test = test; this.lastMutationResult.put(mutation, copy); } } }
/** * Returns true iif the test case execution has thrown an instance of ExceptionInInitializerError * * @param execResult of the test case execution * @return true if the test case has thrown an ExceptionInInitializerError */ private static boolean hasThrownInitializerError(ExecutionResult execResult) { for (Throwable t : execResult.getAllThrownExceptions()) { if (t instanceof ExceptionInInitializerError) { return true; } } return false; }
/** * <p> * hasTimeout * </p> * * @param result * a {@link org.evosuite.testcase.execution.ExecutionResult} object. * @return a boolean. */ public static boolean hasTimeout(ExecutionResult result) { if (result == null) { logger.warn("Result is null!"); return false; } else if (result.test == null) { logger.warn("Test is null!"); return false; } int size = result.test.size(); if (result.isThereAnExceptionAtPosition(size)) { if (result.getExceptionThrownAtPosition(size) instanceof TestCaseExecutor.TimeoutExceeded) { return true; } } return false; }
private void removeAssertionsAfterException(List<ExecutionResult> results) { for(ExecutionResult result : results) { if(result.noThrownExceptions()) continue; int exceptionPosition = result.getFirstPositionOfThrownException(); // TODO: Not clear how that can happen... if(result.test.size() > exceptionPosition) result.test.getStatement(exceptionPosition).removeAssertions(); } }
if (result.hasTimeout() || result.hasTestException() || result.calledReflection()) { continue; touchedMutants.addAll(result.getTrace().getTouchedMutants()); Map<Integer, Double> touchedMutantsDistances = result.getTrace().getMutationDistances(); if (touchedMutantsDistances.isEmpty()) {
ExecutionResult result = new ExecutionResult(test, null); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); result.setExecutionTime(System.currentTimeMillis() - threadStopper.getStartTime()); result.setExecutedStatements(num.get()); result.setThrownExceptions(exceptionsThrown); result.setReadProperties(org.evosuite.runtime.System.getAllPropertiesReadSoFar()); result.setWasAnyPropertyWritten(org.evosuite.runtime.System.wasAnyPropertyWritten());
/** * If there is an exception in a superconstructor, then the corresponding * constructor might not be included in the execution trace * * @param results * @param callCount */ private static boolean hasConstructorException(ExecutionResult result, String className, String methodName) { if (result.hasTimeout() || result.hasTestException() || result.noThrownExceptions()) return false; Integer exceptionPosition = result.getFirstPositionOfThrownException(); if(!result.test.hasStatement(exceptionPosition)){ return false; } Statement statement = result.test.getStatement(exceptionPosition); if (statement instanceof ConstructorStatement) { ConstructorStatement c = (ConstructorStatement) statement; String constructorClassName = c.getConstructor().getName(); String constructorMethodName = "<init>" + Type.getConstructorDescriptor(c.getConstructor().getConstructor()); if(constructorClassName.equals(className) && constructorMethodName.equals(methodName)) { return true; } } return false; }
if (result.hasTimeout() || result.hasTestException() || result.noThrownExceptions() || result.calledReflection()) { continue; for (Integer i : result.getPositionsWhereExceptionsWereThrown()) { if(ExceptionCoverageHelper.shouldSkip(result,i)){ continue;
boolean wasSecurityException = result.hasSecurityException(); Integer pos = result.getFirstPositionOfThrownException(); if (pos != null) { if (result.getExceptionThrownAtPosition(pos) instanceof CodeUnderTestException) { test.chop(pos); } else { result.exposeExceptionMapping(), visitor).split("\\r?\\n")) { builder.append(CODE_SPACE); builder.append(line);
continue; if (executionResult.noThrownExceptions()) { logger.info("Adding carved test without exception"); logger.info(test.toCode()); } else { logger.info("Exception thrown in carved test {}: {}", testName, executionResult.getExceptionThrownAtPosition(executionResult.getFirstPositionOfThrownException())); for (StackTraceElement elem : executionResult.getExceptionThrownAtPosition(executionResult.getFirstPositionOfThrownException()).getStackTrace()) { logger.info(elem.toString()); logger.info(test.toCode(executionResult.exposeExceptionMapping())); if (Properties.CHOP_CARVED_EXCEPTIONS) { logger.info("Chopping exception of carved test");
ExecutionResult result = new ExecutionResult(defaultTestCase, null); DSEStats.getInstance().reportNewConcolicExecutionTime(estimatedConcolicExecutionTime); MaxStatementsStoppingCondition.statementsExecuted(result.getExecutedStatements()); if (!result.noThrownExceptions()) { int idx = result.getFirstPositionOfThrownException(); logger.info("Exception thrown: " + result.getExceptionThrownAtPosition(idx));
result.setSecurityException(PermissionStatistics.getInstance().getAndResetExceptionInfo()); } catch (ThreadDeath t) { logger.warn("Caught ThreadDeath during test execution"); ExecutionResult result = new ExecutionResult(tc, null); result.setThrownExceptions(callable.getExceptionsThrown()); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); ExecutionTracer.getExecutionTracer().clear(); return result; ExecutionResult result = new ExecutionResult(tc, null); result.setThrownExceptions(callable.getExceptionsThrown()); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); ExecutionTracer.getExecutionTracer().clear(); return result; ExecutionResult result = new ExecutionResult(tc, null); result.setThrownExceptions(callable.getExceptionsThrown()); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); ExecutionTracer.getExecutionTracer().clear(); if (e1.getCause() instanceof Error) { // an error was thrown ExecutionResult result = new ExecutionResult(tc, null); result.setThrownExceptions(callable.getExceptionsThrown()); result.reportNewThrownException(tc.size(), new TestCaseExecutor.TimeoutExceeded()); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); ExecutionTracer.getExecutionTracer().clear(); ExecutionTracer.setKillSwitch(false);
/** {@inheritDoc} */ public static ExecutionResult runTest(TestCase test, Mutation mutant) { ExecutionResult result = new ExecutionResult(test, mutant); try { if (mutant != null) logger.debug("Executing test for mutant " + mutant.getId() + ": \n" + test.toCode()); else logger.debug("Executing test without mutant"); if (mutant != null) MutationObserver.activateMutation(mutant); result = TestCaseExecutor.getInstance().execute(test); if (mutant != null) MutationObserver.deactivateMutation(mutant); int num = test.size(); if (!result.noThrownExceptions()) { num = result.getFirstPositionOfThrownException(); } //if (mutant == null) MaxStatementsStoppingCondition.statementsExecuted(num); int i = 0; for (AssertionTraceObserver<?> observer : observers) { result.setTrace(observer.getTrace(), observerClasses[i++]); } } catch (Exception e) { throw new Error(e); } return result; }
failures.add(new Failure(violation)); if(!Properties.CHECK_CONTRACTS && result.hasUndeclaredException()) { int position = result.getFirstPositionOfThrownException(); Throwable exception = result.getExceptionThrownAtPosition(position); failures.add(new Failure(exception, position, testCase)); testLineCoverage.put(name, result.getTrace().getCoveredLines()); uncoveredLines.removeAll(result.getTrace().getCoveredLines()); for(int branchId : result.getTrace().getCoveredFalseBranches()) { Branch branch = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId); if(branch == null) { branchCoverage.add(info); for(int branchId : result.getTrace().getCoveredTrueBranches()) { Branch branch = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branchId); if(branch == null) {
if (!result.getTrace().getTouchedMutants().contains(mutation.getId())) executionDistance = normalize(getExecutionDistance(result)); else if (executionDistance <= 0 && !result.calledReflection()) { assert (result.getTrace() != null); assert (result.getTrace().getTouchedMutants().contains(mutation.getId())); infectionDistance = normalize(result.getTrace().getMutationDistance(mutation.getId())); logger.debug("Infection distance for mutation = " + infectionDistance); if(result.noThrownExceptions()) { fitness = 0.0; // Exception difference exceptionCase = true;
@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; }
/** * Execute a test case * * @param testChromosome The test case to execute * @return Result of the execution */ public ExecutionResult runTest(TestChromosome testChromosome) { if (testChromosome.getLastExecutionResult() != null && !testChromosome.isChanged()) { return testChromosome.getLastExecutionResult(); } TestCase test = testChromosome.getTestCase(); ExecutionResult result = new ExecutionResult(test, null); try { result = TestCaseExecutor.getInstance().execute(test); int num = test.size(); if (!result.noThrownExceptions()) { num = result.getFirstPositionOfThrownException(); } MaxStatementsStoppingCondition.statementsExecuted(num); // for(TestObserver observer : observers) { // observer.testResult(result); // } } catch (Exception e) { logger.error("TG: Exception caught: ", e); throw new RuntimeException(e); } return result; }
ExecutionResult result = testCh.getLastExecutionResult(); if(result.calledReflection()) return covered_exceptions; for (Integer i : result.getPositionsWhereExceptionsWereThrown()) { if(ExceptionCoverageHelper.shouldSkip(result,i)){ continue;
.removeIf(t -> t.getLastExecutionResult() != null && (t.getLastExecutionResult().hasTimeout() || t.getLastExecutionResult().hasTestException())); result = TestCaseExecutor.runTest(test.getTestCase()); if (result.hasSecurityException()) { int position = result.getFirstPositionOfThrownException(); if (position > 0) { test.getTestCase().chop(position);