/**
* Copyright (C) 2010-2017 Gordon Fraser, Andrea Arcuri and EvoSuite
* contributors
*
* This file is part of EvoSuite.
*
* EvoSuite is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, either version 3.0 of the License, or
* (at your option) any later version.
*
* EvoSuite is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with EvoSuite. If not, see <http://www.gnu.org/licenses/>.
*/
package org.evosuite.testcase.execution;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.evosuite.Properties;
import org.evosuite.TestGenerationContext;
import org.evosuite.Properties.Criterion;
import org.evosuite.coverage.branch.Branch;
import org.evosuite.coverage.branch.BranchPool;
import org.evosuite.coverage.dataflow.DefUse;
import org.evosuite.coverage.dataflow.DefUsePool;
import org.evosuite.coverage.dataflow.Definition;
import org.evosuite.coverage.dataflow.Use;
import org.evosuite.setup.CallContext;
import org.evosuite.statistics.RuntimeVariable;
import org.evosuite.utils.ArrayUtil;
import org.objectweb.asm.Opcodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Keep a trace of the program execution
*
* @author Gordon Fraser
*/
public class ExecutionTraceImpl implements ExecutionTrace, Cloneable {
@Deprecated
public static class BranchEval {
private final int branchId;
private CallContext context = null;
private final double falseDistance;
private final double trueDistance;
public BranchEval(int branchId, double trueDistance, double falseDistance) {
this.branchId = branchId;
this.trueDistance = trueDistance;
this.falseDistance = falseDistance;
}
public BranchEval(int branchId, double trueDistance, double falseDistance, CallContext context) {
this.branchId = branchId;
this.trueDistance = trueDistance;
this.falseDistance = falseDistance;
this.context = context;
}
public int getBranchId() {
return branchId;
}
public CallContext getContext() {
return context;
}
public double getFalseDistance() {
return falseDistance;
}
public double getTrueDistance() {
return trueDistance;
}
@Override
public String toString() {
return "BranchEval [branchId=" + branchId + ", trueDistance=" + trueDistance + ", falseDistance="
+ falseDistance + "]";
}
}
private static final Logger logger = LoggerFactory.getLogger(ExecutionTrace.class);
/** Constant <code>traceCalls=false</code> */
public static boolean traceCalls = false;
public static boolean disableContext = false;
/** Constant <code>traceCoverage=true</code> */
public static boolean traceCoverage = true;
private static void checkSaneCall(MethodCall call) {
if (!((call.trueDistanceTrace.size() == call.falseDistanceTrace.size())
&& (call.falseDistanceTrace.size() == call.defuseCounterTrace.size())
&& (call.defuseCounterTrace.size() == call.branchTrace.size()))) {
throw new IllegalStateException("insane MethodCall: traces should all be of equal size. " + call.explain());
}
}
public static void enableContext() {
// enableTraceCalls();
disableContext = false;
}
public static void disableContext() {
disableTraceCalls();
disableContext = true;
}
/**
* <p>
* disableTraceCalls
* </p>
*/
public static void disableTraceCalls() {
traceCalls = false;
}
/**
* <p>
* enableTraceCalls
* </p>
*/
public static void enableTraceCalls() {
traceCalls = true;
}
public static boolean isTraceCallsEnabled() {
return traceCalls;
}
/**
* <p>
* enableTraceCoverage
* </p>
*/
public static void enableTraceCoverage() {
traceCoverage = true;
}
/**
* Removes from the given ExecutionTrace all finished_calls with an index in
* removableCalls
*/
private static void removeFinishCalls(ExecutionTraceImpl trace, ArrayList<Integer> removableCalls) {
Collections.sort(removableCalls);
for (int i = removableCalls.size() - 1; i >= 0; i--) {
int toRemove = removableCalls.get(i);
MethodCall removed = trace.finishedCalls.remove(toRemove);
if (removed == null) {
throw new IllegalStateException("trace.finished_calls not allowed to contain null");
}
}
}
/**
* Removes from the given MethodCall all trace information with an index in
* removableIndices
*/
private static void removeFromFinishCall(MethodCall call, ArrayList<Integer> removableIndices) {
checkSaneCall(call);
Collections.sort(removableIndices);
for (int i = removableIndices.size() - 1; i >= 0; i--) {
int removableIndex = removableIndices.get(i);
Integer removedBranch = call.branchTrace.remove(removableIndex);
Double removedTrue = call.trueDistanceTrace.remove(removableIndex);
Double removedFalse = call.falseDistanceTrace.remove(removableIndex);
Integer removedCounter = call.defuseCounterTrace.remove(removableIndex);
if ((removedCounter == null) || (removedBranch == null) || (removedTrue == null)
|| (removedFalse == null)) {
throw new IllegalStateException("trace.finished_calls-traces not allowed to contain null");
}
}
}
private List<BranchEval> branchesTrace = new ArrayList<BranchEval>();
// Coverage information
public Map<String, Map<String, Map<Integer, Integer>>> coverage = Collections
.synchronizedMap(new HashMap<String, Map<String, Map<Integer, Integer>>>());
public Map<Integer, Integer> coveredFalse = Collections.synchronizedMap(new HashMap<Integer, Integer>());
public Map<String, Integer> coveredMethods = Collections.synchronizedMap(new HashMap<String, Integer>());
public Map<String, Integer> coveredBranchlessMethods = Collections.synchronizedMap(new HashMap<String, Integer>());
public Map<Integer, Integer> coveredPredicates = Collections.synchronizedMap(new HashMap<Integer, Integer>());
public Map<Integer, Integer> coveredTrue = Collections.synchronizedMap(new HashMap<Integer, Integer>());
public Map<Integer, Integer> coveredDefs = Collections.synchronizedMap(new HashMap<Integer, Integer>());
public Map<Integer, Map<CallContext, Double>> coveredTrueContext = Collections
.synchronizedMap(new HashMap<Integer, Map<CallContext, Double>>());
public Map<Integer, Map<CallContext, Double>> coveredFalseContext = Collections
.synchronizedMap(new HashMap<Integer, Map<CallContext, Double>>());
public Map<Integer, Map<CallContext, Integer>> coveredPredicateContext = Collections
.synchronizedMap(new HashMap<Integer, Map<CallContext, Integer>>());
public Map<String, Map<CallContext, Integer>> coveredMethodContext = Collections
.synchronizedMap(new HashMap<String, Map<CallContext, Integer>>());
// number of seen Definitions and uses for indexing purposes
private int duCounter = 0;
// The last explicitly thrown exception is kept here
private Throwable explicitException = null;
public Map<Integer, Double> falseDistances = Collections.synchronizedMap(new HashMap<Integer, Double>());
private final Map<Integer, Double> falseDistancesSum = Collections.synchronizedMap(new HashMap<Integer, Double>());
// finished_calls;
public List<MethodCall> finishedCalls = Collections.synchronizedList(new ArrayList<MethodCall>());
public Map<Integer, Object> knownCallerObjects = Collections.synchronizedMap(new HashMap<Integer, Object>());
// to differentiate between different MethodCalls
private int methodId = 0;
public Map<Integer, Double> mutantDistances = Collections.synchronizedMap(new HashMap<Integer, Double>());
// for defuse-coverage it is important to keep track of all the objects that
// called the ExecutionTracer
private int objectCounter = 0;
// for each Variable-Name these maps hold the data for which objectID
// at which time (duCounter) which Definition or Use was passed
public Map<String, HashMap<Integer, HashMap<Integer, Integer>>> passedDefinitions = Collections
.synchronizedMap(new HashMap<String, HashMap<Integer, HashMap<Integer, Integer>>>());
public Map<String, HashMap<Integer, HashMap<Integer, Integer>>> passedUses = Collections
.synchronizedMap(new HashMap<String, HashMap<Integer, HashMap<Integer, Integer>>>());
public Map<String, HashMap<Integer, HashMap<Integer, Object>>> passedDefinitionObject = Collections
.synchronizedMap(new HashMap<String, HashMap<Integer, HashMap<Integer, Object>>>());
public Map<String, HashMap<Integer, HashMap<Integer, Object>>> passedUseObject = Collections
.synchronizedMap(new HashMap<String, HashMap<Integer, HashMap<Integer, Object>>>());
private int proxyCount = 1;
// Data information
public Map<String, Map<String, Map<Integer, Integer>>> returnData = Collections
.synchronizedMap(new HashMap<String, Map<String, Map<Integer, Integer>>>());
// active calls
Deque<MethodCall> stack = new LinkedList<MethodCall>();
public Set<Integer> touchedMutants = Collections.synchronizedSet(new HashSet<Integer>());
public Map<Integer, Double> trueDistances = Collections.synchronizedMap(new HashMap<Integer, Double>());
private final Map<Integer, Double> trueDistancesSum = Collections.synchronizedMap(new HashMap<Integer, Double>());
public static Set<Integer> gradientBranches = Collections.synchronizedSet(new HashSet<Integer>());
public static Set<Integer> gradientBranchesCoveredTrue = Collections.synchronizedSet(new HashSet<Integer>());
public static Set<Integer> gradientBranchesCoveredFalse = Collections.synchronizedSet(new HashSet<Integer>());
public static Map<RuntimeVariable, Set<Integer>> bytecodeInstructionReached = Collections
.synchronizedMap(new HashMap<RuntimeVariable, Set<Integer>>());
public static Map<RuntimeVariable, Set<Integer>> bytecodeInstructionCoveredTrue = Collections
.synchronizedMap(new HashMap<RuntimeVariable, Set<Integer>>());
public static Map<RuntimeVariable, Set<Integer>> bytecodeInstructionCoveredFalse = Collections
.synchronizedMap(new HashMap<RuntimeVariable, Set<Integer>>());
/**
* <p>
* Constructor for ExecutionTraceImpl.
* </p>
*/
public ExecutionTraceImpl() {
stack.add(new MethodCall("", "", 0, 0, 0)); // Main method
}
/**
* <p>
* addProxy
* </p>
*/
public void addProxy() {
proxyCount++;
}
/**
* <p>
* removeProxy
* </p>
*/
public void removeProxy() {
proxyCount--;
}
/**
* {@inheritDoc}
*
* Add branch to currently active method call
*/
@Override
public void branchPassed(int branch, int bytecode_id, double true_distance, double false_distance) {
assert (true_distance >= 0.0);
assert (false_distance >= 0.0);
updateTopStackMethodCall(branch, bytecode_id, true_distance, false_distance);
// TODO: property should really be called TRACK_GRADIENT_BRANCHES!
if (Properties.TRACK_BOOLEAN_BRANCHES) {
if ((true_distance != 0 && true_distance != 1) || (false_distance != 0 && false_distance != 1))
gradientBranches.add(branch);
}
if (traceCoverage) {
if (!coveredPredicates.containsKey(branch))
coveredPredicates.put(branch, 1);
else
coveredPredicates.put(branch, coveredPredicates.get(branch) + 1);
if (true_distance == 0.0) {
if (!coveredTrue.containsKey(branch))
coveredTrue.put(branch, 1);
else
coveredTrue.put(branch, coveredTrue.get(branch) + 1);
}
if (false_distance == 0.0) {
if (!coveredFalse.containsKey(branch))
coveredFalse.put(branch, 1);
else
coveredFalse.put(branch, coveredFalse.get(branch) + 1);
}
}
if (Properties.TRACK_COVERED_GRADIENT_BRANCHES) {
if (gradientBranches.contains(branch)) {
if ((coveredTrue.containsKey(branch)))
gradientBranchesCoveredTrue.add(branch);
if ((coveredFalse.containsKey(branch)))
gradientBranchesCoveredFalse.add(branch);
}
}
if (Properties.BRANCH_COMPARISON_TYPES) {
int opcode = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
.getBranch(branch).getInstruction().getASMNode().getOpcode();
int previousOpcode = -2;
if (BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branch)
.getInstruction().getASMNode().getPrevious() != null)
previousOpcode = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
.getBranch(branch).getInstruction().getASMNode().getPrevious().getOpcode();
boolean cTrue = coveredTrue.containsKey(branch);
boolean cFalse = coveredFalse.containsKey(branch);
switch (previousOpcode) {
case Opcodes.LCMP:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_lcmp, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_lcmp, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_lcmp, branch);
break;
case Opcodes.FCMPL:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_fcmpl, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_fcmpl, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_fcmpl, branch);
break;
case Opcodes.FCMPG:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_fcmpg, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_fcmpg, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_fcmpg, branch);
break;
case Opcodes.DCMPL:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_dcmpl, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_dcmpl, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_dcmpl, branch);
break;
case Opcodes.DCMPG:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_dcmpg, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_dcmpg, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_dcmpg, branch);
break;
}
switch (opcode) {
// copmpare int with zero
case Opcodes.IFEQ:
case Opcodes.IFNE:
case Opcodes.IFLT:
case Opcodes.IFGE:
case Opcodes.IFGT:
case Opcodes.IFLE:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_IntZero, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_IntZero, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_IntZero, branch);
break;
// copmpare int with int
case Opcodes.IF_ICMPEQ:
case Opcodes.IF_ICMPNE:
case Opcodes.IF_ICMPLT:
case Opcodes.IF_ICMPGE:
case Opcodes.IF_ICMPGT:
case Opcodes.IF_ICMPLE:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_IntInt, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_IntInt, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_IntInt, branch);
break;
// copmpare reference with reference
case Opcodes.IF_ACMPEQ:
case Opcodes.IF_ACMPNE:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_RefRef, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_RefRef, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_RefRef, branch);
break;
// compare reference with null
case Opcodes.IFNULL:
case Opcodes.IFNONNULL:
trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_RefNull, branch);
if (cTrue)
trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_RefNull, branch);
if (cFalse)
trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_RefNull, branch);
break;
}
}
if (!trueDistances.containsKey(branch))
trueDistances.put(branch, true_distance);
else
trueDistances.put(branch, Math.min(trueDistances.get(branch), true_distance));
if (!falseDistances.containsKey(branch))
falseDistances.put(branch, false_distance);
else
falseDistances.put(branch, Math.min(falseDistances.get(branch), false_distance));
if (!trueDistancesSum.containsKey(branch))
trueDistancesSum.put(branch, true_distance);
else
trueDistancesSum.put(branch, trueDistancesSum.get(branch) + true_distance);
if (!falseDistancesSum.containsKey(branch))
falseDistancesSum.put(branch, false_distance);
else
falseDistancesSum.put(branch, falseDistancesSum.get(branch) + false_distance);
if (!disableContext && (Properties.INSTRUMENT_CONTEXT || Properties.INSTRUMENT_METHOD_CALLS
|| ArrayUtil.contains(Properties.CRITERION, Criterion.IBRANCH)
|| ArrayUtil.contains(Properties.CRITERION, Criterion.CBRANCH))) {
updateBranchContextMaps(branch, true_distance, false_distance);
}
// This requires a lot of memory and should not really be used
if (Properties.BRANCH_EVAL) {
branchesTrace.add(new BranchEval(branch, true_distance, false_distance));
}
}
/**
* Track reach/coverage of branch based on it's underlying opcode during
* execution
*
* @param the
* relevant map for the variable type (one of the three static
* maps)
* @param The
* branch type (based on opcode)
* @param id
* of the tracked branch
*/
private void trackBranchOpcode(Map<RuntimeVariable, Set<Integer>> trackedMap, RuntimeVariable v, int branch_id) {
if (!trackedMap.containsKey(v))
trackedMap.put(v, new HashSet<Integer>());
Set<Integer> branchSet = trackedMap.get(v);
branchSet.add(branch_id);
trackedMap.put(v, branchSet);
}
/**
* @param branch
* @param true_distance
* @param false_distance
*/
private void updateBranchContextMaps(int branch, double true_distance, double false_distance) {
if (!coveredPredicateContext.containsKey(branch)) {
coveredPredicateContext.put(branch, new HashMap<CallContext, Integer>());
coveredTrueContext.put(branch, new HashMap<CallContext, Double>());
coveredFalseContext.put(branch, new HashMap<CallContext, Double>());
}
CallContext context = new CallContext(Thread.currentThread().getStackTrace());
if (!coveredPredicateContext.get(branch).containsKey(context)) {
coveredPredicateContext.get(branch).put(context, 1);
coveredTrueContext.get(branch).put(context, true_distance);
coveredFalseContext.get(branch).put(context, false_distance);
} else {
coveredPredicateContext.get(branch).put(context, coveredPredicateContext.get(branch).get(context) + 1);
coveredTrueContext.get(branch).put(context,
Math.min(coveredTrueContext.get(branch).get(context), true_distance));
coveredFalseContext.get(branch).put(context,
Math.min(coveredFalseContext.get(branch).get(context), false_distance));
}
}
/**
* {@inheritDoc}
*
* Reset to 0
*/
@Override
public void clear() {
finishedCalls = new ArrayList<MethodCall>();
stack = new LinkedList<MethodCall>();
// stack.clear();
// finished_calls.clear();
stack.add(new MethodCall("", "", 0, 0, 0)); // Main method
coverage = new HashMap<String, Map<String, Map<Integer, Integer>>>();
returnData = new HashMap<String, Map<String, Map<Integer, Integer>>>();
methodId = 0;
duCounter = 0;
objectCounter = 0;
knownCallerObjects = new HashMap<Integer, Object>();
trueDistances = new HashMap<Integer, Double>();
falseDistances = new HashMap<Integer, Double>();
mutantDistances = new HashMap<Integer, Double>();
touchedMutants = new HashSet<Integer>();
coveredMethods = new HashMap<String, Integer>();
coveredBranchlessMethods = new HashMap<String, Integer>();
coveredPredicates = new HashMap<Integer, Integer>();
coveredTrue = new HashMap<Integer, Integer>();
coveredFalse = new HashMap<Integer, Integer>();
coveredDefs = new HashMap<Integer, Integer>();
passedDefinitions = new HashMap<String, HashMap<Integer, HashMap<Integer, Integer>>>();
passedUses = new HashMap<String, HashMap<Integer, HashMap<Integer, Integer>>>();
passedDefinitionObject = new HashMap<String, HashMap<Integer, HashMap<Integer, Object>>>();
passedUseObject = new HashMap<String, HashMap<Integer, HashMap<Integer, Object>>>();
branchesTrace = new ArrayList<BranchEval>();
coveredTrueContext = new HashMap<Integer, Map<CallContext, Double>>();
coveredFalseContext = new HashMap<Integer, Map<CallContext, Double>>();
coveredPredicateContext = new HashMap<Integer, Map<CallContext, Integer>>();
}
/**
* {@inheritDoc}
*
* Create a deep copy
*/
@Override
public ExecutionTraceImpl clone() {
ExecutionTraceImpl copy = new ExecutionTraceImpl();
for (MethodCall call : finishedCalls) {
copy.finishedCalls.add(call.clone());
}
// copy.finished_calls.addAll(finished_calls);
copy.coverage = new HashMap<String, Map<String, Map<Integer, Integer>>>();
if (coverage != null) {
copy.coverage.putAll(coverage);
}
copy.returnData = new HashMap<String, Map<String, Map<Integer, Integer>>>();
copy.returnData.putAll(returnData);
/*
* if(stack != null && !stack.isEmpty() && stack.peek().method_name !=
* null && stack.peek().method_name.equals("")) { logger.info(
* "Copying main method"); copy.finished_calls.add(stack.peek()); }
*/
copy.trueDistances.putAll(trueDistances);
copy.falseDistances.putAll(falseDistances);
copy.coveredMethods.putAll(coveredMethods);
copy.coveredBranchlessMethods.putAll(coveredBranchlessMethods);
copy.coveredPredicates.putAll(coveredPredicates);
copy.coveredTrue.putAll(coveredTrue);
copy.coveredFalse.putAll(coveredFalse);
copy.coveredDefs.putAll(coveredDefs);
copy.touchedMutants.addAll(touchedMutants);
copy.mutantDistances.putAll(mutantDistances);
copy.passedDefinitions.putAll(passedDefinitions);
copy.passedUses.putAll(passedUses);
copy.passedDefinitionObject.putAll(passedDefinitionObject);
copy.passedUseObject.putAll(passedUseObject);
copy.branchesTrace.addAll(branchesTrace);
copy.coveredTrueContext.putAll(coveredTrueContext);
copy.coveredFalseContext.putAll(coveredFalseContext);
copy.coveredPredicateContext.putAll(coveredPredicateContext);
copy.methodId = methodId;
copy.duCounter = duCounter;
copy.objectCounter = objectCounter;
copy.knownCallerObjects.putAll(knownCallerObjects);
copy.proxyCount = 1;
return copy;
}
/**
* {@inheritDoc}
*
* Adds Definition-Use-Coverage trace information for the given definition.
*
* Registers the given caller-Object Traces the occurrence of the given
* definition in the passedDefs-field Sets the given definition as the
* currently active one for the definitionVariable in the
* activeDefinitions-field Adds fake trace information to the currently
* active MethodCall in this.stack
*/
@Override
public void definitionPassed(Object object, Object caller, int defID) {
if (!traceCalls) {
return;
}
Definition def = DefUsePool.getDefinitionByDefId(defID);
if (def == null) {
throw new IllegalStateException("expect DefUsePool to known defIDs that are passed by instrumented code");
}
if (!coveredDefs.containsKey(defID)) {
coveredDefs.put(defID, 0);
} else {
coveredDefs.put(defID, coveredDefs.get(defID) + 1);
}
String varName = def.getVariableName();
int objectID = registerObject(caller);
// if this is a static variable, treat objectID as zero for consistency
// in the representation of static data
if (objectID != 0 && def.isStaticDefUse())
objectID = 0;
if (passedDefinitions.get(varName) == null) {
passedDefinitions.put(varName, new HashMap<Integer, HashMap<Integer, Integer>>());
passedDefinitionObject.put(varName, new HashMap<Integer, HashMap<Integer, Object>>());
}
HashMap<Integer, Integer> defs = passedDefinitions.get(varName).get(objectID);
HashMap<Integer, Object> defsObject = passedDefinitionObject.get(varName).get(objectID);
if (defs == null) {
defs = new HashMap<Integer, Integer>();
defsObject = new HashMap<Integer, Object>();
}
defs.put(duCounter, defID);
defsObject.put(duCounter, object);
passedDefinitions.get(varName).put(objectID, defs);
passedDefinitionObject.get(varName).put(objectID, defsObject);
// logger.trace(duCounter+": set active definition for var
// "+def.getDUVariableName()+" on object "+objectID+" to Def "+defID);
duCounter++;
}
/**
* {@inheritDoc}
*
* Add a new method call to stack
*/
@Override
public void enteredMethod(String className, String methodName, Object caller) {
if (traceCoverage) {
String id = className + "." + methodName;
if (!coveredMethods.containsKey(id)) {
coveredMethods.put(id, 1);
} else {
coveredMethods.put(id, coveredMethods.get(id) + 1);
}
// Set<String> bms = BranchPool.getBranchlessMethods();
if (BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
.isBranchlessMethod(className, id)) {
if (!coveredBranchlessMethods.containsKey(id)) {
coveredBranchlessMethods.put(id, 1);
} else {
coveredBranchlessMethods.put(id, coveredBranchlessMethods.get(id) + 1);
}
}
}
if (!className.equals("") && !methodName.equals("")) {
if (traceCalls) {
int callingObjectID = registerObject(caller);
methodId++;
MethodCall call = new MethodCall(className, methodName, methodId, callingObjectID, stack.size());
if (ArrayUtil.contains(Properties.CRITERION, Criterion.DEFUSE)
|| ArrayUtil.contains(Properties.CRITERION, Criterion.ALLDEFS)) {
call.branchTrace.add(-1);
call.trueDistanceTrace.add(1.0);
call.falseDistanceTrace.add(0.0);
call.defuseCounterTrace.add(duCounter);
// TODO line_trace ?
}
stack.push(call);
}
if (!disableContext
&& (Properties.INSTRUMENT_CONTEXT || ArrayUtil.contains(Properties.CRITERION, Criterion.IBRANCH)
|| ArrayUtil.contains(Properties.CRITERION, Criterion.CBRANCH))) {
updateMethodContextMaps(className, methodName, caller);
}
}
}
/**
* @param className
* @param methodName
* @param caller
*/
private void updateMethodContextMaps(String className, String methodName, Object caller) {
String id = className + "." + methodName;
if (!coveredMethodContext.containsKey(id)) {
coveredMethodContext.put(id, new HashMap<CallContext, Integer>());
}
CallContext context = new CallContext(Thread.currentThread().getStackTrace());
if (!coveredMethodContext.get(id).containsKey(context)) {
coveredMethodContext.get(id).put(context, 1);
} else {
coveredMethodContext.get(id).put(context, coveredMethodContext.get(id).get(context) + 1);
}
}
/** {@inheritDoc} */
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
ExecutionTraceImpl other = (ExecutionTraceImpl) obj;
if (coverage == null) {
if (other.coverage != null) {
return false;
}
} else if (!coverage.equals(other.coverage)) {
return false;
}
if (finishedCalls == null) {
if (other.finishedCalls != null) {
return false;
}
} else if (!finishedCalls.equals(other.finishedCalls)) {
return false;
}
if (returnData == null) {
if (other.returnData != null) {
return false;
}
} else if (!returnData.equals(other.returnData)) {
return false;
}
if (stack == null) {
if (other.stack != null) {
return false;
}
} else if (!stack.equals(other.stack)) {
return false;
}
return true;
}
/**
* {@inheritDoc}
*
* Pop last method call from stack
*/
@Override
public void exitMethod(String classname, String methodname) {
if (!classname.equals("") && !methodname.equals("")) {
if (traceCalls) {
if (!stack.isEmpty() && !(stack.peek().methodName.equals(methodname))) {
logger.debug("Expecting " + stack.peek().methodName + ", got " + methodname);
if (stack.peek().methodName.equals("") && !stack.peek().branchTrace.isEmpty()) {
logger.debug("Found main method");
finishedCalls.add(stack.pop());
} else {
logger.debug("Bugger!");
// Usually, this happens if we use mutation testing and
// the mutation causes an unexpected exception or
// timeout
stack.pop();
}
} else {
finishedCalls.add(stack.pop());
}
}
}
}
/** {@inheritDoc} */
@Override
public synchronized void finishCalls() {
logger.debug("At the end, we have " + stack.size() + " calls left on stack");
while (!stack.isEmpty()) {
finishedCalls.add(stack.pop());
}
}
/** {@inheritDoc} */
@Override
public List<BranchEval> getBranchesTrace() {
return branchesTrace;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoverageData()
*/
/** {@inheritDoc} */
@Override
public Map<String, Map<String, Map<Integer, Integer>>> getCoverageData() {
return coverage;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredFalseBranches()
*/
/** {@inheritDoc} */
@Override
public Set<Integer> getCoveredFalseBranches() {
Set<Integer> covered = new HashSet<Integer>();
for (Entry<Integer, Double> entry : falseDistances.entrySet()) {
if (entry.getValue() == 0.0)
covered.add(entry.getKey());
}
return covered;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredLines()
*/
/** {@inheritDoc} */
@Override
public Set<Integer> getCoveredLines(String className) {
Set<Integer> coveredLines = new HashSet<Integer>();
for (Entry<String, Map<String, Map<Integer, Integer>>> entry : coverage.entrySet()) {
if ((entry.getKey().equals(className)) ||
// is it a internal class of 'className' ?
(entry.getKey().startsWith(className + "$"))) {
for (Map<Integer, Integer> methodentry : entry.getValue().values()) {
coveredLines.addAll(methodentry.keySet());
}
}
}
return coveredLines;
}
@Override
public Set<Integer> getCoveredLines() {
return this.getCoveredLines(Properties.TARGET_CLASS);
}
@Override
public Set<Integer> getAllCoveredLines() {
Set<Integer> coveredLines = new HashSet<Integer>();
for (Entry<String, Map<String, Map<Integer, Integer>>> entry : coverage.entrySet()) {
for (Map<Integer, Integer> methodentry : entry.getValue().values()) {
coveredLines.addAll(methodentry.keySet());
}
}
return coveredLines;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredMethods()
*/
/** {@inheritDoc} */
@Override
public Set<String> getCoveredMethods() {
return coveredMethods.keySet();
}
@Override
public Set<String> getCoveredBranchlessMethods() {
return coveredBranchlessMethods.keySet();
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredPredicates()
*/
/** {@inheritDoc} */
@Override
public Set<Integer> getCoveredPredicates() {
return coveredPredicates.keySet();
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredTrueBranches()
*/
/** {@inheritDoc} */
@Override
public Set<Integer> getCoveredTrueBranches() {
Set<Integer> covered = new HashSet<Integer>();
for (Entry<Integer, Double> entry : trueDistances.entrySet()) {
if (entry.getValue() == 0.0)
covered.add(entry.getKey());
}
return covered;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getCoveredDefinitions()
*/
@Override
public Set<Integer> getCoveredDefinitions() {
return coveredDefs.keySet();
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getDefinitionExecutionCount()
*/
@Override
public Map<Integer, Integer> getDefinitionExecutionCount() {
return coveredDefs;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getDefinitionData()
*/
/** {@inheritDoc} */
@Override
public Map<String, HashMap<Integer, HashMap<Integer, Integer>>> getDefinitionData() {
return passedDefinitions;
}
public Map<String, HashMap<Integer, HashMap<Integer, Object>>> getDefinitionDataObjects() {
return passedDefinitionObject;
}
/** {@inheritDoc} */
@Override
public Throwable getExplicitException() {
return explicitException;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getFalseDistance(int)
*/
/** {@inheritDoc} */
@Override
public double getFalseDistance(int branchId) {
return falseDistances.get(branchId);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getFalseDistances()
*/
/** {@inheritDoc} */
@Override
public Map<Integer, Double> getFalseDistances() {
return falseDistances;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getMethodCalls()
*/
/** {@inheritDoc} */
@Override
public List<MethodCall> getMethodCalls() {
return finishedCalls;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getMethodExecutionCount()
*/
/** {@inheritDoc} */
@Override
public Map<String, Integer> getMethodExecutionCount() {
return coveredMethods;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getMutationDistance(int)
*/
/** {@inheritDoc} */
@Override
public double getMutationDistance(int mutationId) {
return mutantDistances.get(mutationId);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getMutationDistances()
*/
/** {@inheritDoc} */
@Override
public Map<Integer, Double> getMutationDistances() {
return mutantDistances;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getPassedDefinitions(java.lang.
* String)
*/
/** {@inheritDoc} */
@Override
public Map<Integer, HashMap<Integer, Integer>> getPassedDefinitions(String variableName) {
return passedDefinitions.get(variableName);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getPassedUses(java.lang.String)
*/
/** {@inheritDoc} */
@Override
public Map<Integer, HashMap<Integer, Integer>> getPassedUses(String variableName) {
return passedUses.get(variableName);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getPredicateExecutionCount()
*/
/** {@inheritDoc} */
@Override
public Map<Integer, Integer> getPredicateExecutionCount() {
return coveredPredicates;
}
/**
* <p>
* Getter for the field <code>proxyCount</code>.
* </p>
*
* @return a int.
*/
public int getProxyCount() {
return proxyCount;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getReturnData()
*/
/** {@inheritDoc} */
@Override
public Map<String, Map<String, Map<Integer, Integer>>> getReturnData() {
return returnData;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getTouchedMutants()
*/
/** {@inheritDoc} */
@Override
public Set<Integer> getTouchedMutants() {
return touchedMutants;
}
@Override
public Set<Integer> getInfectedMutants() {
Set<Integer> infectedMutants = new LinkedHashSet<Integer>();
for (Entry<Integer, Double> entry : mutantDistances.entrySet()) {
if (entry.getValue() == 0.0) {
infectedMutants.add(entry.getKey());
}
}
return infectedMutants;
}
/**
* {@inheritDoc}
*
* Returns a copy of this trace where all MethodCall-information traced from
* objects other then the one identified by the given objectID is removed
* from the finished_calls-field
*
* WARNING: this will not affect this.true_distances and other fields of
* ExecutionTrace this only affects the finished_calls field (which should
* suffice for BranchCoverageFitness-calculation)
*/
@Override
public ExecutionTrace getTraceForObject(int objectId) {
ExecutionTraceImpl r = clone();
ArrayList<Integer> removableCalls = new ArrayList<Integer>();
for (int i = 0; i < r.finishedCalls.size(); i++) {
MethodCall call = r.finishedCalls.get(i);
if ((call.callingObjectID != objectId) && (call.callingObjectID != 0)) {
removableCalls.add(i);
}
}
removeFinishCalls(r, removableCalls);
return new ExecutionTraceProxy(r);
}
/**
* {@inheritDoc}
*
* Returns a copy of this trace where all MethodCall-information associated
* with duCounters outside the range of the given duCounter-Start and -End
* is removed from the finished_calls-traces
*
* finished_calls without any point in the trace at which the given
* duCounter range is hit are removed completely
*
* Also traces for methods other then the one that holds the given targetDU
* are removed as well as trace information that would pass the branch of
* the given targetDU If wantToCoverTargetDU is false instead those
* targetDUBranch information is removed that would pass the alternative
* branch of targetDU
*
* The latter is because this method only gets called when the given
* targetDU was not active in the given duCounter-range if and only if
* wantToCoverTargetDU is set, and since useFitness calculation is on branch
* level and the branch of the targetDU can be passed before the targetDU is
* passed this can lead to a flawed branchFitness.
*
*
* WARNING: this will not affect this.true_distances and other fields of
* ExecutionTrace this only affects the finished_calls field (which should
* suffice for BranchCoverageFitness-calculation)
*/
@Override
public ExecutionTrace getTraceInDUCounterRange(DefUse targetDU, boolean wantToCoverTargetDU, int duCounterStart,
int duCounterEnd) {
if (duCounterStart > duCounterEnd) {
throw new IllegalArgumentException("start has to be lesser or equal end");
/*
* // DONE: bug // this still has a major flaw: s.
* MeanTestClass.mean(): // right now its like we map branches to
* activeDefenitions // but especially in the root branch of a
* method // activeDefenitions change during execution time // FIX:
* in order to avoid these false positives remove all information //
* for a certain branch if some information for that branch is
* supposed to be removed // subTodo since branchPassed() only gets
* called when a branch is passed initially // fake calls to
* branchPassed() have to be made whenever a DU is passed // s.
* definitionPassed(), usePassed() and
* addFakeActiveMethodCallInformation()
*
* // DONE: new bug // turns out thats an over-approximation that
* makes it // impossible to cover some potentially coverable goals
*
* // completely new: // if your definition gets overwritten in a
* trace // the resulting fitness should be the fitness of not
* taking the branch with the overwriting definition // DONE: in
* order to do that don't remove older trace information for an
* overwritten branch // but rather set the true and false distance
* of that previous branch information to the distance of not taking
* the overwriting branch // done differently: s.
* DefUseCoverageTestFitness.getFitness()
*/
}
ExecutionTraceImpl r = clone();
Branch targetDUBranch = targetDU.getControlDependentBranch();
ArrayList<Integer> removableCalls = new ArrayList<Integer>();
for (int callPos = 0; callPos < r.finishedCalls.size(); callPos++) {
MethodCall call = r.finishedCalls.get(callPos);
// check if call is for the method of targetDU
if (!call.methodName.equals(targetDU.getMethodName())) {
removableCalls.add(callPos);
continue;
}
ArrayList<Integer> removableIndices = new ArrayList<Integer>();
for (int i = 0; i < call.defuseCounterTrace.size(); i++) {
int currentDUCounter = call.defuseCounterTrace.get(i);
int currentBranchBytecode = call.branchTrace.get(i);
if (currentDUCounter < duCounterStart || currentDUCounter > duCounterEnd)
removableIndices.add(i);
else if (currentBranchBytecode == targetDUBranch.getInstruction().getInstructionId()) {
// only remove this point in the trace if it would cover
// targetDU
boolean targetExpressionValue = targetDU.getControlDependentBranchExpressionValue();
if (targetExpressionValue) {
if (call.trueDistanceTrace.get(i) == 0.0)
removableIndices.add(i);
} else {
if (call.falseDistanceTrace.get(i) == 0.0)
removableIndices.add(i);
}
}
}
removeFromFinishCall(call, removableIndices);
if (call.defuseCounterTrace.size() == 0)
removableCalls.add(callPos);
}
removeFinishCalls(r, removableCalls);
return new ExecutionTraceProxy(r);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getTrueDistance(int)
*/
/** {@inheritDoc} */
@Override
public double getTrueDistance(int branchId) {
return trueDistances.get(branchId);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getTrueDistances()
*/
/** {@inheritDoc} */
@Override
public Map<Integer, Double> getTrueDistances() {
return trueDistances;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getUseData()
*/
/** {@inheritDoc} */
@Override
public Map<String, HashMap<Integer, HashMap<Integer, Integer>>> getUseData() {
return passedUses;
}
public Map<String, HashMap<Integer, HashMap<Integer, Object>>> getUseDataObjects() {
return passedUseObject;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#wasCoveredFalse(int)
*/
/** {@inheritDoc} */
@Override
public boolean hasFalseDistance(int predicateId) {
return falseDistances.containsKey(predicateId);
}
/** {@inheritDoc} */
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((coverage == null) ? 0 : coverage.hashCode());
result = prime * result + ((finishedCalls == null) ? 0 : finishedCalls.hashCode());
result = prime * result + ((returnData == null) ? 0 : returnData.hashCode());
result = prime * result + ((stack == null) ? 0 : stack.hashCode());
return result;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#wasCoveredTrue(int)
*/
/** {@inheritDoc} */
@Override
public boolean hasTrueDistance(int predicateId) {
return trueDistances.containsKey(predicateId);
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#lazyClone()
*/
/** {@inheritDoc} */
@Override
public ExecutionTrace lazyClone() {
// TODO Auto-generated method stub
return null;
}
private boolean stackHasMethod(String methodName) {
for (MethodCall call : stack) {
if (call.methodName.equals(methodName))
return true;
}
return false;
}
/**
* {@inheritDoc}
*
* Add line to currently active method call
*/
@Override
public void linePassed(String className, String methodName, int line) {
if (traceCalls) {
if (stack.isEmpty()) {
logger.info("Method stack is empty: " + className + "." + methodName + " - l" + line); // TODO
// switch
// back
// logger.debug to
// logger.warn
} else {
boolean empty = false;
if (!stack.peek().methodName.equals(methodName)) {
if (stack.peek().methodName.equals(""))
return;
if (stackHasMethod(methodName)) {
do {
logger.debug("Popping method " + stack.peek().methodName + " because we were looking for "
+ methodName);
finishedCalls.add(stack.pop());
} while (!stack.isEmpty() && !stack.peek().methodName.equals(methodName)
&& !stack.peek().methodName.equals(""));
} else {
logger.warn("Popping method " + stack.peek().methodName + " because we were looking for "
+ methodName);
logger.warn("Current stack: " + stack);
finishedCalls.add(stack.pop());
}
if (stack.isEmpty()) {
logger.warn("Method stack is empty: " + className + "." + methodName + " - l" + line); // TODO
// switch
// back
empty = true;
}
}
if (!empty)
stack.peek().lineTrace.add(line);
}
}
if (traceCoverage) {
if (!coverage.containsKey(className)) {
coverage.put(className, new HashMap<String, Map<Integer, Integer>>());
}
if (!coverage.get(className).containsKey(methodName)) {
coverage.get(className).put(methodName, new HashMap<Integer, Integer>());
}
if (!coverage.get(className).get(methodName).containsKey(line)) {
coverage.get(className).get(methodName).put(line, 1);
} else {
coverage.get(className).get(methodName).put(line,
coverage.get(className).get(methodName).get(line) + 1);
}
}
}
/** {@inheritDoc} */
@Override
public void mutationPassed(int mutationId, double distance) {
touchedMutants.add(mutationId);
if (!mutantDistances.containsKey(mutationId)) {
mutantDistances.put(mutationId, distance);
} else {
mutantDistances.put(mutationId, Math.min(distance, mutantDistances.get(mutationId)));
}
}
/**
* Returns the objecectId for the given object.
*
* The ExecutionTracer keeps track of all objects it gets called from in
* order to distinguish them later in the fitness calculation for the
* defuse-Coverage-Criterion.
*/
private int registerObject(Object caller) {
if (caller == null) {
return 0;
}
for (Integer objectId : knownCallerObjects.keySet()) {
if (knownCallerObjects.get(objectId) == caller) {
return objectId;
}
}
// object unknown so far
objectCounter++;
knownCallerObjects.put(objectCounter, caller);
return objectCounter;
}
/** {@inheritDoc} */
@Override
public void returnValue(String className, String methodName, int value) {
if (!returnData.containsKey(className)) {
returnData.put(className, new HashMap<String, Map<Integer, Integer>>());
}
if (!returnData.get(className).containsKey(methodName)) {
returnData.get(className).put(methodName, new HashMap<Integer, Integer>());
}
if (!returnData.get(className).get(methodName).containsKey(value)) {
// logger.info("Got return value "+value);
returnData.get(className).get(methodName).put(value, 1);
} else {
// logger.info("Got return value again "+value);
returnData.get(className).get(methodName).put(value,
returnData.get(className).get(methodName).get(value) + 1);
}
}
/** {@inheritDoc} */
@Override
public void setExplicitException(Throwable explicitException) {
this.explicitException = explicitException;
}
/**
* {@inheritDoc}
*
* Returns a String containing the information in passedDefs and passedUses
*
* Used for Definition-Use-Coverage-debugging
*/
@Override
public String toDefUseTraceInformation() {
StringBuffer r = new StringBuffer();
for (String var : passedDefinitions.keySet()) {
r.append(" for variable: " + var + ": ");
for (Integer objectId : passedDefinitions.get(var).keySet()) {
if (passedDefinitions.get(var).keySet().size() > 1) {
r.append("\n\ton object " + objectId + ": ");
}
r.append(toDefUseTraceInformation(var, objectId));
}
r.append("\n ");
}
return r.toString();
}
/**
* {@inheritDoc}
*
* Returns a String containing the information in passedDefs and passedUses
* filtered for a specific variable
*
* Used for Definition-Use-Coverage-debugging
*/
@Override
public String toDefUseTraceInformation(String targetVar) {
StringBuffer r = new StringBuffer();
for (Integer objectId : passedDefinitions.get(targetVar).keySet()) {
if (passedDefinitions.get(targetVar).keySet().size() > 1) {
r.append("\n\ton object " + objectId + ": ");
}
r.append(toDefUseTraceInformation(targetVar, objectId));
}
r.append("\n ");
return r.toString();
}
/**
* {@inheritDoc}
*
* Returns a String containing the information in passedDefs and passedUses
* for the given variable
*
* Used for Definition-Use-Coverage-debugging
*/
@Override
public String toDefUseTraceInformation(String var, int objectId) {
if (passedDefinitions.get(var) == null) {
return "";
}
if ((objectId == -1) && (passedDefinitions.get(var).keySet().size() == 1)) {
objectId = (Integer) passedDefinitions.get(var).keySet().toArray()[0];
}
if (passedDefinitions.get(var).get(objectId) == null) {
return "";
}
// gather all DUs
String[] duTrace = new String[this.duCounter];
for (int i = 0; i < this.duCounter; i++) {
duTrace[i] = "";
}
for (Integer duPos : passedDefinitions.get(var).get(objectId).keySet()) {
duTrace[duPos] = "(" + duPos + ":Def " + passedDefinitions.get(var).get(objectId).get(duPos) + ")";
}
if ((passedUses.get(var) != null) && (passedUses.get(var).get(objectId) != null)) {
for (Integer duPos : passedUses.get(var).get(objectId).keySet()) {
duTrace[duPos] = "(" + duPos + ":Use " + passedUses.get(var).get(objectId).get(duPos) + ")";
}
}
// build up the String
StringBuffer r = new StringBuffer();
for (String s : duTrace) {
r.append(s);
if (s.length() > 0) {
r.append(", ");
}
}
// remove last ", "
String traceString = r.toString();
if (traceString.length() > 2) {
return traceString.substring(0, traceString.length() - 2);
}
return traceString;
}
/** {@inheritDoc} */
@Override
public String toString() {
StringBuffer ret = new StringBuffer();
for (MethodCall m : finishedCalls) {
ret.append(m);
}
ret.append("\nCovered methods: ");
for (Entry<String, Integer> entry : coveredMethods.entrySet()) {
ret.append(entry.getKey() + ": " + entry.getValue() + ", ");
}
ret.append("\nCovered predicates: ");
for (Entry<Integer, Integer> entry : coveredPredicates.entrySet()) {
ret.append(entry.getKey() + ": " + entry.getValue() + ", ");
}
ret.append("\nTrue distances: ");
for (Entry<Integer, Double> entry : trueDistances.entrySet()) {
ret.append(entry.getKey() + ": " + entry.getValue() + ", ");
}
ret.append("\nFalse distances: ");
for (Entry<Integer, Double> entry : falseDistances.entrySet()) {
ret.append(entry.getKey() + ": " + entry.getValue() + ", ");
}
return ret.toString();
}
/**
* Adds trace information to the active MethodCall in this.stack
*/
private void updateTopStackMethodCall(int branch, int bytecode_id, double true_distance, double false_distance) {
if (traceCalls) {
if (stack.isEmpty()) {
return;
}
stack.peek().branchTrace.add(branch); // was: bytecode_id
stack.peek().trueDistanceTrace.add(true_distance);
stack.peek().falseDistanceTrace.add(false_distance);
assert ((true_distance == 0.0) || (false_distance == 0.0));
// TODO line_trace ?
if (ArrayUtil.contains(Properties.CRITERION, Criterion.DEFUSE)
|| ArrayUtil.contains(Properties.CRITERION, Criterion.ALLDEFS)) {
stack.peek().defuseCounterTrace.add(duCounter);
}
}
}
/**
* {@inheritDoc}
*
* Adds Definition-Use-Coverage trace information for the given use.
*
* Registers the given caller-Object Traces the occurrence of the given use
* in the passedUses-field
*/
@Override
public void usePassed(Object object, Object caller, int useID) {
if (!traceCalls) // TODO ???
return;
Use use = DefUsePool.getUseByUseId(useID);
int objectID = registerObject(caller);
// if this is a static variable, treat objectID as zero for consistency
// in the representation of static data
if (objectID != 0) {
if (use == null)
throw new IllegalStateException(
"expect DefUsePool to known defIDs that are passed by instrumented code");
if (use.isStaticDefUse())
objectID = 0;
}
String varName = use.getVariableName();
if (passedUses.get(varName) == null) {
passedUses.put(varName, new HashMap<Integer, HashMap<Integer, Integer>>());
passedUseObject.put(varName, new HashMap<Integer, HashMap<Integer, Object>>());
}
HashMap<Integer, Integer> uses = passedUses.get(varName).get(objectID);
HashMap<Integer, Object> usesObject = passedUseObject.get(varName).get(objectID);
if (uses == null) {
uses = new HashMap<Integer, Integer>();
usesObject = new HashMap<Integer, Object>();
}
uses.put(duCounter, useID);
usesObject.put(duCounter, object);
passedUses.get(varName).put(objectID, uses);
passedUseObject.get(varName).put(objectID, usesObject);
duCounter++;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#wasMutationTouched(int)
*/
/** {@inheritDoc} */
@Override
public boolean wasMutationTouched(int mutationId) {
return touchedMutants.contains(mutationId);
}
/** {@inheritDoc} */
@Override
public Map<Integer, Double> getFalseDistancesSum() {
return falseDistancesSum;
}
/** {@inheritDoc} */
@Override
public Map<Integer, Double> getTrueDistancesSum() {
return trueDistancesSum;
}
/** {@inheritDoc} */
@Override
public Map<String, HashMap<Integer, HashMap<Integer, Integer>>> getPassedUses() {
return passedUses;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getPassedDefIDs()
*/
// Map<String, HashMap<Integer, HashMap<Integer, Integer>>>
@Override
public Set<Integer> getPassedDefIDs() {
Set<Integer> defs = new HashSet<Integer>();
for (HashMap<Integer, HashMap<Integer, Integer>> classDefs : passedDefinitions.values()) {
for (HashMap<Integer, Integer> currentDefs : classDefs.values()) {
defs.addAll(currentDefs.values());
}
}
return defs;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getPassedUseIDs()
*/
@Override
public Set<Integer> getPassedUseIDs() {
Set<Integer> uses = new HashSet<Integer>();
for (HashMap<Integer, HashMap<Integer, Integer>> classUses : passedUses.values()) {
for (HashMap<Integer, Integer> currentUses : classUses.values()) {
uses.addAll(currentUses.values());
}
}
return uses;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getTrueDistancesContext()
*/
@Override
public Map<Integer, Map<CallContext, Double>> getTrueDistancesContext() {
return coveredTrueContext;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getFalseDistancesContext()
*/
@Override
public Map<Integer, Map<CallContext, Double>> getFalseDistancesContext() {
return coveredFalseContext;
}
/*
* (non-Javadoc)
*
* @see
* org.evosuite.testcase.ExecutionTrace#getPredicateContextExecutionCount()
*/
@Override
public Map<Integer, Map<CallContext, Integer>> getPredicateContextExecutionCount() {
return coveredPredicateContext;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.testcase.ExecutionTrace#getMethodContextCount()
*/
@Override
public Map<String, Map<CallContext, Integer>> getMethodContextCount() {
return coveredMethodContext;
}
/**
* This set keeps those classes that have a static write (i.e. PUTSTATIC)
* during test execution.
*/
private final HashSet<String> classesWithStaticWrites = new HashSet<String>();
@Override
public void putStaticPassed(String classNameWithDots, String fieldName) {
classesWithStaticWrites.add(classNameWithDots);
}
/**
* This set keeps those classes that have a static read (i.e. GETSTATIC)
* during test execution.
*/
private final HashSet<String> classesWithStaticReads = new HashSet<String>();
@Override
public void getStaticPassed(String classNameWithDots, String fieldName) {
classesWithStaticReads.add(classNameWithDots);
}
@Override
public Set<String> getClassesWithStaticWrites() {
return classesWithStaticWrites;
}
/**
* This field keeps the names of those classes that were initialized (ie
* <clinit> was completed during this test execution). The list has no
* repetitions.
*/
private final List<String> initializedClasses = new LinkedList<String>();
/**
* Adds the class to the list of those classes that were initialized during
* this test execution. The class is not added if it was already contained
* in the list.
*/
@Override
public void classInitialized(String classNameWithDots) {
if (!initializedClasses.contains(classNameWithDots)) {
initializedClasses.add(classNameWithDots);
}
}
@Override
public Set<String> getClassesWithStaticReads() {
return classesWithStaticReads;
}
@Override
public List<String> getInitializedClasses() {
return this.initializedClasses;
}
}