/** * <p> * enable * </p> */ public static void enable() { ExecutionTracer tracer = ExecutionTracer.getExecutionTracer(); tracer.disabled = false; }
/** * <p> * Setter for the field <code>killSwitch</code>. * </p> * * @param value * a boolean. */ public static void setKillSwitch(boolean value) { ExecutionTracer tracer = ExecutionTracer.getExecutionTracer(); tracer.killSwitch = value; }
/** * <p> * disable * </p> */ public static void disable() { ExecutionTracer tracer = ExecutionTracer.getExecutionTracer(); tracer.disabled = true; }
/** * <p> * isEnabled * </p> * * @return a boolean. */ public static boolean isEnabled() { ExecutionTracer tracer = ExecutionTracer.getExecutionTracer(); return !tracer.disabled; }
/** * 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 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(); } }
/** * <p> * statementExecuted * </p> */ public static void statementExecuted() { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.num_statements++; }
/** * Called by instrumented code each time a variable is read from (a Use) * * @param caller * a {@link java.lang.Object} object. * @param useID * a int. */ public static void passedUse(Object object, Object caller, int useID) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; tracer.trace.usePassed(object, caller, useID); }
/** * 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 return values is produced * * @param value * a int. * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. */ public static void returnValue(int value, String className, String methodName) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; //logger.trace("Return value: " + value); tracer.trace.returnValue(className, methodName, value); }
/** * 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); }
public static void passedPutStatic(String classNameWithDots, String fieldName) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.putStaticPassed(classNameWithDots, fieldName); }
/** * * @param classNameWithDots * @param fieldName */ public static void passedGetStatic(String classNameWithDots, String fieldName) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.getStaticPassed(classNameWithDots, fieldName); }
/** * 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); }
/** * Called by the instrumented code each time a new source line is executed * * @param line * a int. * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. */ public static void passedLine(String className, String methodName, int line) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.linePassed(className, methodName, line); }
/** * <p> * passedMutation * </p> * * @param distance * a double. * @param mutationId * a int. */ public static void passedMutation(double distance, int mutationId) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.mutationPassed(mutationId, distance); }
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; }
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); } } }
/** * Reports the initialized classes during class initialization to the * ClassReInitializater and configures the ClassReInitializer accordingly */ private void configureClassReInitializer() { // add loaded classes during building of dependency graph ExecutionTrace execTrace = ExecutionTracer.getExecutionTracer().getTrace(); final List<String> initializedClasses = execTrace.getInitializedClasses(); ClassReInitializer.getInstance().addInitializedClasses(initializedClasses); // set the behaviour of the ClassReInitializer final boolean reset_all_classes = Properties.RESET_ALL_CLASSES_DURING_TEST_GENERATION; ClassReInitializer.getInstance().setReInitializeAllClasses(reset_all_classes); }