ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); distance_true = val2 == null ? 0.0 : 1.0; } else { disable(); try { distance_true = val1.equals(val2) ? 0.0 : 1.0; distance_true = 1.0; } finally { enable(); distance_true = val2 == null ? 1.0 : 0.0; } else { disable(); try { distance_true = val1.equals(val2) ? 1.0 : 0.0; distance_true = 1.0; } finally { enable();
/** * <p> * getExecutionTracer * </p> * * @return a {@link org.evosuite.testcase.execution.ExecutionTracer} object. */ public static ExecutionTracer getExecutionTracer() { if (instance == null) { instance = new ExecutionTracer(); } return instance; }
/** * <p> * statementExecuted * </p> */ public static void statementExecuted() { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.num_statements++; }
/** * Called by the instrumented code each time a new source line is executed */ public static void checkTimeout() { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (tracer.killSwitch) { // logger.info("Raising TimeoutException as kill switch is active - passedLine"); if(!isInStaticInit()) throw new TestCaseExecutor.TimeoutExceeded(); } }
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.getExecutionTracer().clear(); 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; } catch (ExecutionException e1) { 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 ExecutionTracer.setKillSwitch(true); try { handler.getLastTask().get(Properties.SHUTDOWN_TIMEOUT, TimeUnit.MILLISECONDS); ExecutionTracer.setKillSwitch(false); logger.info("Run still not finished, but awaiting for static initializer to finish."); ExecutionTracer.setKillSwitch(true);
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; }
if (isThreadNeqCurrentThread()) return; if (!ExecutionTracer.isEnabled()) return; returnValue(0, className, methodName); return; ExecutionTracer.disable(); tmp = new StringBuilder(value.toString()); } catch (Throwable t) { return; } finally { ExecutionTracer.enable(); returnValue(tmp.toString().hashCode(), className, methodName);
/** * Called when an atomic test has finished. whether the test successes or fails */ @Override public void testFinished(Description description) { LoggingUtils.getEvoLogger().info("* Finished: " + "ClassName: " + description.getClassName() + ", MethodName: " + description.getMethodName()); this.testResult.setRuntime(System.nanoTime() - this.start); this.testResult.setExecutionTrace(ExecutionTracer.getExecutionTracer().getTrace()); this.testResult.incrementRunCount(); ExecutionTracer.getExecutionTracer().clear(); this.junitRunner.addResult(this.testResult); }
/** * <p>runSuite</p> * * @param name a {@link java.lang.String} object. */ public void runSuite(String name) { try { Class<?> forName = null; forName = Class.forName(name); logger.info("Running against JUnit test suite " + name); JUnitCore.runClasses(forName); ExecutionTrace trace = ExecutionTracer.getExecutionTracer().getTrace(); coveredMethods = new HashSet<String>(); coveredBranchesTrue = trace.getCoveredTrueBranches(); coveredBranchesFalse = trace.getCoveredFalseBranches(); for (String methodName : trace.getCoveredMethods()) { if (!methodName.contains("$")) coveredMethods.add(methodName); } } catch (ClassNotFoundException e) { e.printStackTrace(); } }
/** * 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); }
ExecutionTracer.statementExecuted(); informObservers_before(s); result.setThrownExceptions(exceptionsThrown); result.reportNewThrownException(test.size(), exceptionThrown); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); break; if (ExecutionTracer.getExecutionTracer().getLastException() == exceptionThrown) { result.explicitExceptions.put(num.get(), true); } else {
ExecutionTracer.enable(); result.setTrace(ExecutionTracer.getExecutionTracer().getTrace()); result.setExecutionTime(System.currentTimeMillis() - threadStopper.getStartTime()); result.setExecutedStatements(num.get());
ExecutionTracer.enableTraceCalls();
/** {@inheritDoc} */ @Override public double getFitness(TestSuiteChromosome suite) { ExecutionTracer.enableTraceCalls(); int coveredGoals = 0; for (T goal : getCoverageGoals()) { for (TestChromosome test : suite.getTestChromosomes()) { if (goal.isCovered(test)) { coveredGoals++; break; } } } ExecutionTracer.disableTraceCalls(); return getCoverageGoals().size() - coveredGoals; } }
/** * Called by instrumented code each time a field method call is passed * * Since it was not clear whether the field method call constitutes a * definition or a use when the instrumentation was initially added this * method will redirect the call accordingly * * @param caller * @param defuseId */ public static void passedFieldMethodCall(Object callee, Object caller, int defuseId) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; if (DefUsePool.isKnownAsDefinition(defuseId)) { Definition passedDef = DefUsePool.getDefinitionByDefUseId(defuseId); passedDefinition(callee, caller, passedDef.getDefId()); } else if (DefUsePool.isKnownAsUse(defuseId)) { Use passedUse = DefUsePool.getUseByDefUseId(defuseId); passedUse(callee, caller, passedUse.getUseId()); } else throw new EvosuiteError( "instrumentation called passedFieldMethodCall with invalid defuseId: " + defuseId + ", known IDs: " + DefUsePool.getDefUseCounter()); }
/** * <p> * enable * </p> */ public static void enable() { ExecutionTracer tracer = ExecutionTracer.getExecutionTracer(); tracer.disabled = false; }
private static void reinstrument(TestSuiteChromosome testSuite, Properties.Criterion criterion) { if (ArrayUtil.contains(Properties.SECONDARY_OBJECTIVE, Properties.SecondaryObjective.IBRANCH)) { ExecutionTracer.enableContext(); } if (!ExecutionTracer.isTraceCallsEnabled()) { ExecutionTracer.enableTraceCalls(); } testSuite.setChanged(true); for (TestChromosome test : testSuite.getTestChromosomes()) { test.setChanged(true); test.clearCachedResults(); // clears last execution result and last mutation result } Properties.Criterion oldCriterion[] = Arrays.copyOf(Properties.CRITERION, Properties.CRITERION.length); Properties.CRITERION = new Properties.Criterion[]{criterion}; logger.info("Re-instrumenting for criterion: " + criterion); TestGenerationContext.getInstance().resetContext(); // Need to load class explicitly in case there are no test cases. // If there are tests, then this is redundant Properties.getInitializedTargetClass(); // TODO: Now all existing test cases have reflection objects pointing to the wrong classloader logger.info("Changing classloader of test suite for criterion: " + criterion); for (TestChromosome test : testSuite.getTestChromosomes()) { DefaultTestCase dtest = (DefaultTestCase) test.getTestCase(); dtest.changeClassLoader(TestGenerationContext.getInstance().getClassLoaderForSUT()); } Properties.CRITERION = oldCriterion; }