/** {@inheritDoc} */ @SuppressWarnings("unchecked") @Override public synchronized OutputTrace<T> clone() { OutputTrace<T> copy = new OutputTrace<T>(); for (Integer position : trace.keySet()) { copy.trace.put(position, new HashMap<Integer, T>()); for (Integer var : trace.get(position).keySet()) { copy.trace.get(position).put(var, (T) trace.get(position).get(var).cloneEntry()); } } return copy; }
/** {@inheritDoc} */ @Override public void addAssertions(TestCase test) { ExecutionResult result = runTest(test); for (OutputTrace<?> trace : result.getTraces()) { trace.getAllAssertions(test); trace.clear(); } logger.debug("Test after adding assertions: " + test.toCode()); } }
/** * <p> * Getter for the field <code>trace</code>. * </p> * * @return a {@link org.evosuite.assertion.OutputTrace} object. */ public synchronized OutputTrace<T> getTrace() { return trace.clone(); }
@SuppressWarnings({ "rawtypes", "unchecked" }) private int getNumAssertions(ExecutionResult origResult, ExecutionResult mutant_result) { int num = 0; if (origResult.test.size() == 0) { logger.debug("Orig test is empty?"); return 0; } for (Class<?> observerClass : observerClasses) { OutputTrace trace = mutant_result.getTrace(observerClass); OutputTrace orig = origResult.getTrace(observerClass); if (orig == null) { String msg = "No trace for " + observerClass + ". Traces: "; for (OutputTrace t : origResult.getTraces()) msg += " " + t.toString(); logger.error(msg); } else { num += orig.numDiffer(trace); } } logger.debug("Found " + num + " assertions!"); return num; }
|| origResult.getTrace(observerClass) == null) continue; numKilled += origResult.getTrace(observerClass).getAssertions(test, mutantResult.getTrace(observerClass)); if (mutationTraces.containsKey(m)) { for (OutputTrace<?> trace : mutationTraces.get(m)) { if (trace.isDetectedBy(assertion)) { isKilled = true; break; trace.getAllAssertions(test);
trace.addEntry(statement.getPosition(), var, new ArrayLengthTraceEntry(var, arrlength));
int i = 0; for (OutputTrace<?> trace : mutation_traces.get(m)) { isKilled = trace.isDetectedBy(assertion); if (isKilled) { logger.debug("Mutation killed: " + m.getId() + " by trace " + i++);
/** {@inheritDoc} */ @Override public synchronized void clear() { //if(!checkThread()) // return; trace.clear(); }
/** {@inheritDoc} */ @Override public void addAssertions(TestCase test) { ExecutionResult result = runTest(test); for (OutputTrace<?> trace : result.getTraces()) { trace.getAllAssertions(test); } for (int i = 0; i < test.size(); i++) { Statement s = test.getStatement(i); if (!isRelevant(s, test)) s.removeAssertions(); } }
result1.getTrace(observerClass).getAssertions(regressionTest.getTheTest().getTestCase(), result2.getTrace(observerClass));
trace.addEntry(position, var, entry);
protected void filterFailingAssertions(TestCase test) { // Make sure we are not keeping assertions influenced by static state // TODO: Need to handle statically initialized classes ExecutionResult result = runTest(test); Set<Assertion> invalidAssertions = new HashSet<Assertion>(); for(Assertion assertion : test.getAssertions()) { for(OutputTrace<?> outputTrace : result.getTraces()) { if(outputTrace.isDetectedBy(assertion)) { invalidAssertions.add(assertion); break; } } } logger.info("Removing {} nondeterministic assertions", invalidAssertions.size()); for(Assertion assertion : invalidAssertions) { test.removeAssertion(assertion); } }
trace.addEntry(statement.getPosition(), var, new PrimitiveTraceEntry(var, object));
.getAssertions()) { for (OutputTrace<?> outputTrace : resultA.getTraces()) { if (outputTrace.isDetectedBy(assertion)) { logger.error("shouldn't be happening: assertion was failing on original version"); invalidAssertions.add(assertion); if (outputTrace.isDetectedBy(assertion) && !invalidAssertions.contains(assertion)) { count++; break;
/** {@inheritDoc} */ @Override public ExecutionResult clone() { ExecutionResult copy = new ExecutionResult(test, mutation); copy.exceptions.putAll(exceptions); copy.trace = trace.lazyClone(); copy.explicitExceptions.putAll(explicitExceptions); copy.executionTime = executionTime; copy.regressionObjectDistance = regressionObjectDistance; copy.inputGoals = new LinkedHashMap<>(inputGoals); copy.outputGoals = new LinkedHashMap<>(outputGoals); for (Class<?> clazz : traces.keySet()) { copy.traces.put(clazz, traces.get(clazz).clone()); } if(readProperties!=null){ copy.readProperties = new LinkedHashSet<String>(); copy.readProperties.addAll(readProperties); } copy.wasAnyPropertyWritten = wasAnyPropertyWritten; return copy; }
trace.addEntry(statement.getPosition(), var, new ArrayTraceEntry(var, getArray(object)));
+ " at statement " + statement.getPosition()); trace.addEntry(statement.getPosition(), var, entry);
trace.addEntry(statement.getPosition(), var, entry); } catch (CodeUnderTestException e) { logger.debug("", e);
trace.addEntry(statement.getPosition(), var, entry); } catch (CodeUnderTestException e) { logger.debug("", e);
trace.addEntry(statement.getPosition(), var, entry); } catch (CodeUnderTestException e) { logger.debug("", e);