protected void informObservers_finished(ExecutionResult result) { ExecutionTracer.disable(); try { for (ExecutionObserver observer : observers) { observer.testExecutionFinished(result, scope); } } finally { ExecutionTracer.enable(); } }
/** * Inform all observers that we are going to execute the input statement * * @param s * the statement to execute */ protected void informObservers_before(Statement s) { ExecutionTracer.disable(); try { for (ExecutionObserver observer : observers) { observer.beforeStatement(s, scope); } } finally { ExecutionTracer.enable(); } }
ExecutionTracer.enable();
/** * Inform all observers that input statement has been executed * * @param s * the executed statement * @param exceptionThrown * the exception thrown when executing the statement, if any (can * be null) */ protected void informObservers_after(Statement s, Throwable exceptionThrown) { ExecutionTracer.disable(); try { for (ExecutionObserver observer : observers) { observer.afterStatement(s, scope, exceptionThrown); } } finally { ExecutionTracer.enable(); } }
/** * <p> * Constructor for EnumPrimitiveStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param value * a T object. */ @SuppressWarnings("unchecked") public EnumPrimitiveStatement(TestCase tc, T value) { super(tc, value.getClass(), value); boolean tracerEnabled = ExecutionTracer.isEnabled(); if (tracerEnabled) ExecutionTracer.disable(); enumClass = (Class<T>) retrieveEnumClass(value.getClass()); constants = (T[]) retrieveEnumClass(value.getClass()).getEnumConstants(); if (tracerEnabled) ExecutionTracer.enable(); }
if (object1.equals(object2)) { if (!object2.equals(object1)) { ExecutionTracer.enable(); return new ContractViolation(this, statement, exception, pair.object1, pair.object2); ExecutionTracer.enable(); return new ContractViolation(this, statement, exception, pair.object1, pair.object2); ExecutionTracer.enable();
return; } finally { ExecutionTracer.enable();
private static List<JUnitResult> executeTests(Class<?>... testClasses) { ExecutionTracer.enable(); ExecutionTracer.setCheckCallerThread(false); ExecutionTracer.getExecutionTracer().clear(); List<JUnitResult> results = new ArrayList<JUnitResult>(); for (Class<?> testClass : testClasses) { LoggingUtils.getEvoLogger().info(" Executing " + testClass.getSimpleName()); // Set the context classloader in case the SUT requests it Thread.currentThread().setContextClassLoader(testClass.getClassLoader()); JUnitRunner jR = new JUnitRunner(testClass); jR.run(); results.addAll(jR.getTestResults()); } ExecutionTracer.disable(); LoggingUtils.getEvoLogger().info("* " + ClientProcess.getPrettyPrintIdentifier() + "Executed " + results.size() + " unit " + "test(s)"); ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Tests_Executed, results.size()); return results; }
public Class<?> instrumentClass(String fullyQualifiedTargetClass) { Class<?> result = instrumentedClasses.get(fullyQualifiedTargetClass); if (result != null) { assert Properties.TARGET_CLASS.equals(fullyQualifiedTargetClass); assert Properties.PROJECT_PREFIX.equals(fullyQualifiedTargetClass); return result; } try { Properties.TARGET_CLASS = fullyQualifiedTargetClass; Properties.PROJECT_PREFIX = fullyQualifiedTargetClass; ExecutionTracer.enable(); ClassLoader classLoader = new TestabilityTransformationClassLoader(); result = classLoader.loadClass(fullyQualifiedTargetClass); instrumentedClasses.put(fullyQualifiedTargetClass, result); return result; } catch (ClassNotFoundException exc) { throw new RuntimeException(exc); } } }
ExecutionTracer.enable(); super.runChild(method, notifier); boolean result = resultListener.hasFailure;
private ExecutionTrace execute(String methodName, Integer val1, Integer val2) { try { ExecutionTracer.enable(); Class<?> targetClass = classTransformer.instrumentClass(fullyQualifiedTargetClass); Constructor<?> constructor = targetClass.getConstructor(); Object target = constructor.newInstance(); Method method = targetClass.getMethod(methodName, Integer.class, Integer.class); method.invoke(target, val1, val2); ExecutionTrace execTrace = ExecutionTracer.getExecutionTracer().getTrace(); ExecutionTracer.getExecutionTracer().clear(); return execTrace; } catch (Exception exc) { throw new RuntimeException(exc); } } }
ExecutionTracer.enable();
/** * Create a random individual * * @param size */ private TestCase getRandomTestCase(int size) { boolean tracerEnabled = ExecutionTracer.isEnabled(); if (tracerEnabled) ExecutionTracer.disable(); TestCase test = getNewTestCase(); int num = 0; // Choose a random length in 0 - size int length = Randomness.nextInt(size); while (length == 0) length = Randomness.nextInt(size); TestFactory testFactory = TestFactory.getInstance(); // Then add random stuff while (test.size() < length && num < Properties.MAX_ATTEMPTS) { testFactory.insertRandomStatement(test, test.size() - 1); num++; } if (logger.isDebugEnabled()) logger.debug("Randomized test case:" + test.toCode()); if (tracerEnabled) ExecutionTracer.enable(); return test; }
ExecutionTracer.enable();
ExecutionTracer.getExecutionTracer().clear(); ExecutionTracer.setKillSwitch(false); ExecutionTracer.enable(); System.setOut(systemOut); System.setErr(systemErr);
@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(); }
Properties.PROJECT_PREFIX = originalClass.getPackage().getName(); ClassLoaderTestSubject original = new ClassLoaderTestSubject(); ExecutionTracer.enable(); ExecutionTracer.getExecutionTracer().clear(); original.assess(6);