protected boolean checkThread() { return ExecutionTracer.isThreadNeqCurrentThread(); }
/** * 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); }
/** * <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 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); }
public static void passedPutStatic(String classNameWithDots, String fieldName) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.putStaticPassed(classNameWithDots, fieldName); }
/** * 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); }
/** * * @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); }
/** * <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); }
if (isThreadNeqCurrentThread()) return;
/** * 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); }
/** * 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); }
return; if (isThreadNeqCurrentThread()) return;
/** * <p> * exceptionThrown * </p> * * @param exception * a {@link java.lang.Object} object. * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. */ public static void exceptionThrown(Object exception, String className, String methodName) { ExecutionTracer tracer = getExecutionTracer(); if (tracer.disabled) return; if (isThreadNeqCurrentThread()) return; checkTimeout(); tracer.trace.setExplicitException((Throwable) exception); }
return; if (isThreadNeqCurrentThread()) return;
return; if (isThreadNeqCurrentThread()) return;
return; if (isThreadNeqCurrentThread()) return;
/** * 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()); }