Open Source Repository

Home /junit/junit-4.10 | Repository Home


junit/framework/TestResult.java
package junit.framework;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;

/**
 * A <code>TestResult</code> collects the results of executing
 * a test case. It is an instance of the Collecting Parameter pattern.
 * The test framework distinguishes between <i>failures</i> and <i>errors</i>.
 * A failure is anticipated and checked for with assertions. Errors are
 * unanticipated problems like an {@link ArrayIndexOutOfBoundsException}.
 *
 @see Test
 */
public class TestResult extends Object {
  protected List<TestFailure> fFailures;
  protected List<TestFailure> fErrors;
  protected List<TestListener> fListeners;
  protected int fRunTests;
  private boolean fStop;
  
  public TestResult() {
    fFailures= new ArrayList<TestFailure>();
    fErrors= new ArrayList<TestFailure>();
    fListeners= new ArrayList<TestListener>();
    fRunTests= 0;
    fStop= false;
  }
  /**
   * Adds an error to the list of errors. The passed in exception
   * caused the error.
   */
  public synchronized void addError(Test test, Throwable t) {
    fErrors.add(new TestFailure(test, t));
    for (TestListener each : cloneListeners())
      each.addError(test, t);
  }
  /**
   * Adds a failure to the list of failures. The passed in exception
   * caused the failure.
   */
  public synchronized void addFailure(Test test, AssertionFailedError t) {
    fFailures.add(new TestFailure(test, t));
    for (TestListener each : cloneListeners())
      each.addFailure(test, t);
  }
  /**
   * Registers a TestListener
   */
  public synchronized void addListener(TestListener listener) {
    fListeners.add(listener);
  }
  /**
   * Unregisters a TestListener
   */
  public synchronized void removeListener(TestListener listener) {
    fListeners.remove(listener);
  }
  /**
   * Returns a copy of the listeners.
   */
  private synchronized List<TestListener> cloneListeners() {
    List<TestListener> result= new ArrayList<TestListener>();
    result.addAll(fListeners);
    return result;
  }
  /**
   * Informs the result that a test was completed.
   */
  public void endTest(Test test) {
    for (TestListener each : cloneListeners())
      each.endTest(test);
  }
  /**
   * Gets the number of detected errors.
   */
  public synchronized int errorCount() {
    return fErrors.size();
  }
  /**
   * Returns an Enumeration for the errors
   */
  public synchronized Enumeration<TestFailure> errors() {
    return Collections.enumeration(fErrors);
  }
  

  /**
   * Gets the number of detected failures.
   */
  public synchronized int failureCount() {
    return fFailures.size();
  }
  /**
   * Returns an Enumeration for the failures
   */
  public synchronized Enumeration<TestFailure> failures() {
    return Collections.enumeration(fFailures);
  }
  
  /**
   * Runs a TestCase.
   */
  protected void run(final TestCase test) {
    startTest(test);
    Protectable p= new Protectable() {
      public void protect() throws Throwable {
        test.runBare();
      }
    };
    runProtected(test, p);

    endTest(test);
  }
  /**
   * Gets the number of run tests.
   */
  public synchronized int runCount() {
    return fRunTests;
  }
  /**
   * Runs a TestCase.
   */
  public void runProtected(final Test test, Protectable p) {
    try {
      p.protect();
    
    catch (AssertionFailedError e) {
      addFailure(test, e);
    }
    catch (ThreadDeath e) { // don't catch ThreadDeath by accident
      throw e;
    }
    catch (Throwable e) {
      addError(test, e);
    }
  }
  /**
   * Checks whether the test run should stop
   */
  public synchronized boolean shouldStop() {
    return fStop;
  }
  /**
   * Informs the result that a test will be started.
   */
  public void startTest(Test test) {
    final int count= test.countTestCases();
    synchronized(this) {
      fRunTests+= count;
    }
    for (TestListener each : cloneListeners())
      each.startTest(test);
  }
  /**
   * Marks that the test run should stop.
   */
  public synchronized void stop() {
    fStop= true;
  }
  /**
   * Returns whether the entire test was successful or not.
   */
  public synchronized boolean wasSuccessful() {
    return failureCount() == && errorCount() == 0;
  }
}