private void processTraces(
List<PDefinition> definitions, String className, String traceName, TraceXmlWrapper storage)
throws Exception {
try {
Settings.prechecks = true;
Settings.postchecks = true;
Settings.dynamictypechecks = true;
if (storage != null) {
storage.StartClass(className);
}
Integer numberOfTraces = 0;
for (Object string : definitions) {
if (string instanceof ANamedTraceDefinition) {
numberOfTraces++;
}
}
infoProcessingClass(className, numberOfTraces);
List<ANamedTraceDefinition> traceDefs = getAllTraceDefinitions(definitions, traceName);
for (ANamedTraceDefinition def : traceDefs) {
evaluateTraceDefinition(className, storage, def);
}
infoCompleted();
if (DEBUG) {
System.out.println("Completed");
}
} catch (ContextException e) {
error(e.getMessage());
throw e;
} catch (ValueException e) {
error(e.getMessage());
throw e;
} catch (Exception e) {
error(e.getMessage());
throw e;
} finally {
if (storage != null) {
storage.Stop();
}
}
}
private void evaluateTests(
String className, TraceXmlWrapper storage, Object traceDefinition, Context ctxt)
throws Exception {
ANamedTraceDefinition mtd = (ANamedTraceDefinition) traceDefinition;
TestSequence tests = null;
if (!reduce) {
subset = 1.0F;
traceReductionType = TraceReductionType.NONE;
seed = 999;
}
tests =
ctxt.assistantFactory
.createANamedTraceDefinitionAssistant()
.getTests(mtd, ctxt, subset, traceReductionType, seed);
int size = tests.size();
infoProcessingTrace(className, mtd.getName().getName(), size);
if (storage != null) {
storage.StartTrace(
mtd.getName().getName(),
mtd.getLocation().getFile().getName(),
mtd.getLocation().getStartLine(),
mtd.getLocation().getStartPos(),
size,
new Float(subset),
TraceReductionType.valueOf(traceReductionType.toString()),
new Long(seed));
}
INode traceContainer = null;
Environment rootEnv = null;
if (interpreter instanceof ClassInterpreter) {
traceContainer = mtd.getClassDefinition();
rootEnv =
new PrivateClassEnvironment(
interpreter.getAssistantFactory(),
mtd.getClassDefinition(),
interpreter.getGlobalEnvironment());
;
} else {
traceContainer = mtd.parent();
if (((AModuleModules) traceContainer).getIsFlat()) {
// search for the combined module
for (AModuleModules m : ((ModuleInterpreter) interpreter).modules) {
if (m instanceof CombinedDefaultModule) {
traceContainer = m;
break;
}
}
}
rootEnv =
new ModuleEnvironment(interpreter.getAssistantFactory(), (AModuleModules) traceContainer);
}
int n = 1;
int faildCount = 0;
int inconclusiveCount = 0;
int skippedCount = 0;
StopWatch.set();
for (CallSequence test : tests) {
StopWatch.stop("Getting test");
infoProcessingTest(className, mtd.getName().getName(), n, size);
List<Object> result = null;
Verdict verdict = null;
// type check
boolean typeOk = false;
try {
if (interpreter instanceof ClassInterpreter) {
typeCheck(traceContainer, interpreter, test, rootEnv);
} else {
typeCheck(traceContainer, interpreter, test, rootEnv);
}
typeOk = true;
} catch (Exception e) {
result = new Vector<Object>();
result.add(e);
verdict = Verdict.FAILED;
result.add(verdict);
}
// interpret
if (typeOk) {
StopWatch.set();
result = evaluateCallSequence(mtd, test);
StopWatch.stop("Executing ");
StopWatch.set();
verdict = (Verdict) result.get(result.size() - 1);
if (verdict == Verdict.ERROR) {
} else {
tests.filter(result, test, n);
}
}
switch (verdict) {
case FAILED:
faildCount++;
break;
case INCONCLUSIVE:
inconclusiveCount++;
break;
default:
break;
}
if (storage != null) {
/*
* Bodge until we figure out how to not have explicit op names.
*/
String clean = test.toString().replaceAll("\\.\\w+`", ".");
storage.StartTest(new Integer(n).toString(), clean);
storage.StopElement();
}
if (test.getFilter() > 0) {
skippedCount++;
infoTestFiltered(n, test.getFilter(), test);
if (storage != null) {
storage.AddSkippedResult(new Integer(n).toString());
}
} else {
if (verdict == Verdict.ERROR) {
if (storage != null) {
storage.AddResults(new Integer(n).toString(), result);
storage.AddTraceStatus(
Verdict.valueOf(Verdict.FAILED.toString()),
size,
skippedCount,
faildCount,
inconclusiveCount);
storage.StopElement();
}
Exception e = (Exception) result.get(result.size() - 2);
result.remove(result.size() - 2);
throw e;
}
if (storage != null) {
storage.AddResults(new Integer(n).toString(), result);
}
}
n++;
StopWatch.stop("store&filter");
StopWatch.set();
}
if (storage != null) {
Verdict worstVerdict = Verdict.PASSED;
if (faildCount > 0) {
worstVerdict = Verdict.FAILED;
} else if (inconclusiveCount > 0) {
worstVerdict = Verdict.INCONCLUSIVE;
}
storage.AddTraceStatus(
Verdict.valueOf(worstVerdict.toString()),
size,
skippedCount,
faildCount,
inconclusiveCount);
storage.StopElement();
}
infoProcessingTraceFinished(
className, mtd.getName().getName(), size, faildCount, inconclusiveCount, skippedCount);
}
