public static void main(String[] args) {
TestSuite suite = new TestSuite(CmefServiceTest.class);
TestResult results = new TestResult();
try {
suite.run(results);
} finally {
int numOfTests = results.runCount();
int errors = results.errorCount();
int failures = results.failureCount();
System.err.println("Tests executed:\t\t\t" + numOfTests);
System.err.println("Tests succeeded:\t\t" + (numOfTests - (errors + failures)));
System.err.println("Tests resulting in error:\t" + errors);
Enumeration<TestFailure> errorTests = results.errors();
System.err.println("Tests with errors:");
while (errorTests.hasMoreElements()) {
TestFailure fail = errorTests.nextElement();
System.err.println(fail.failedTest());
}
System.err.println("Tests resulting in failure:\t" + failures);
errorTests = results.failures();
System.err.println("Tests with failures:");
while (errorTests.hasMoreElements()) {
TestFailure fail = errorTests.nextElement();
System.err.println(fail.failedTest());
}
}
}
private static List<TestFailure> createTestFailures(
@NotNull InMemoryJavaGenerationHandler generationHandler, List<SModel> models) {
List<TestFailure> testFailures = new ArrayList<TestFailure>();
junit.framework.TestResult result = new junit.framework.TestResult();
invokeTests(generationHandler, models, result, null);
testFailures.addAll(Collections.list(result.failures()));
testFailures.addAll(Collections.list(result.errors()));
return testFailures;
}
/** this testcase uses the file success.py contained in the same directory as this testcase */
@Test
public void testRunSuccessfulTestCase() throws Throwable {
RuntimeStub runtime = new RuntimeStub();
MarathonTestCase t = new MarathonTestCase(new File("./success.py"), runtime);
TestResult result = t.run();
if (result.errorCount() > 0) {
TestFailure failure = (TestFailure) result.errors().nextElement();
throw failure.thrownException();
}
assertEquals("failed", true, result.wasSuccessful());
}
public void testExceptionRunningAndTearDown() {
// This test documents the current behavior. With 1.4, we should
// wrap the exception thrown while running with the exception thrown
// while tearing down
Test t =
new TornDown() {
public void tearDown() {
throw new Error("tearDown");
}
};
TestResult result = new TestResult();
t.run(result);
TestFailure failure = (TestFailure) result.errors().nextElement();
assertEquals("tearDown", failure.thrownException().getMessage());
}
protected void startTests() {
final TestSuite suite = new TestSuite();
final TestResult result = new TestResult();
final JUnitTest jUnitTest = new JUnitTest("ch.ethz.iks.slp.test");
jUnitTest.setProperties(System.getProperties());
// create the xml result formatter
final JUnitResultFormatter xmlResultFormatter = new XMLJUnitResultFormatter();
final File file = new File(outputDirectory, "TEST-ch.ethz.iks.slp.test" + ".xml");
try {
xmlResultFormatter.setOutput(new FileOutputStream(file));
} catch (FileNotFoundException e) {
// may never happen
e.printStackTrace();
}
result.addListener(xmlResultFormatter);
// create a result formatter that prints to the console
final JUnitResultFormatter consoleResultFormatter = new BriefJUnitResultFormatter();
consoleResultFormatter.setOutput(System.out);
result.addListener(consoleResultFormatter);
// add the actual tests to the test suite
Collection collection = new ArrayList();
collection.add(SelfDiscoveryTest.class);
for (Iterator iterator = collection.iterator(); iterator.hasNext(); ) {
Class clazz = (Class) iterator.next();
// run all methods starting with "test*"
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
if (methods[i].getName().startsWith("test")) {
TestCase testCase;
try {
testCase = (TestCase) clazz.newInstance();
testCase.setName(methods[i].getName());
suite.addTest(testCase);
} catch (InstantiationException e) {
// may never happen
e.printStackTrace();
} catch (IllegalAccessException e) {
// may never happen
e.printStackTrace();
}
}
}
}
// prepare to run tests
final long start = System.currentTimeMillis();
xmlResultFormatter.startTestSuite(jUnitTest);
consoleResultFormatter.startTestSuite(jUnitTest);
// run tests
suite.run(result);
// write stats and close reultformatter
jUnitTest.setCounts(result.runCount(), result.failureCount(), result.errorCount());
jUnitTest.setRunTime(System.currentTimeMillis() - start);
xmlResultFormatter.endTestSuite(jUnitTest);
consoleResultFormatter.endTestSuite(jUnitTest);
// print success of failure
if (result.wasSuccessful()) {
System.exit(0);
} else {
if (result.errorCount() > 0) {
System.err.println("Errors:");
for (Enumeration errors = result.errors(); errors.hasMoreElements(); ) {
TestFailure error = (TestFailure) errors.nextElement();
System.err.println(error.trace());
}
}
if (result.failureCount() > 0) {
System.err.println("Failures:");
for (Enumeration failures = result.failures(); failures.hasMoreElements(); ) {
TestFailure failure = (TestFailure) failures.nextElement();
System.err.println(failure.trace());
}
}
System.exit(1);
}
;
}
public boolean start() throws ContainerException {
ContainerConfig.Container jc = ContainerConfig.getContainer("junit-container", configFile);
// get the tests to run
Iterator<ContainerConfig.Container.Property> ti = jc.properties.values().iterator();
if (ti == null) {
Debug.log("No tests to load", module);
return true;
}
// load the tests into the suite
TestSuite suite = new TestSuite();
while (ti.hasNext()) {
ContainerConfig.Container.Property prop = ti.next();
Class<?> clz = null;
try {
clz = ObjectType.loadClass(prop.value);
suite.addTestSuite(clz);
} catch (Exception e) {
Debug.logError(e, "Unable to load test suite class : " + prop.value, module);
}
}
// holder for the results
results = new TestResult();
// run the tests
suite.run(results);
// dispay the results
Debug.log(
"[JUNIT] Pass: "******" | # Tests: "
+ results.runCount()
+ " | # Failed: "
+ results.failureCount()
+ " # Errors: "
+ results.errorCount(),
module);
if (Debug.infoOn()) {
Debug.log(
"[JUNIT] ----------------------------- ERRORS ----------------------------- [JUNIT]",
module);
Enumeration<?> err = results.errors();
if (!err.hasMoreElements()) {
Debug.log("None");
} else {
while (err.hasMoreElements()) {
Debug.log("--> " + err.nextElement(), module);
}
}
Debug.log(
"[JUNIT] ------------------------------------------------------------------ [JUNIT]",
module);
Debug.log(
"[JUNIT] ---------------------------- FAILURES ---------------------------- [JUNIT]",
module);
Enumeration<?> fail = results.failures();
if (!fail.hasMoreElements()) {
Debug.log("None");
} else {
while (fail.hasMoreElements()) {
Debug.log("--> " + fail.nextElement(), module);
}
}
Debug.log(
"[JUNIT] ------------------------------------------------------------------ [JUNIT]",
module);
}
return true;
}