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());
      }
    }
  }
Exemple #2
0
 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());
 }
Exemple #4
0
 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());
 }
Exemple #5
0
  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;
  }