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 {
      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 e) {
          fErrors.add(new TestFailure(test, e));
          for (TestListener each : cloneListeners()) {
              each.addError(test, e);
          }
      }
  
      /**
       * Adds a failure to the list of failures. The passed in exception
       * caused the failure.
       */
      public synchronized void addFailure(Test test, AssertionFailedError e) {
          fFailures.add(new TestFailure(test, e));
          for (TestListener each : cloneListeners()) {
              each.addFailure(test, e);
          }
      }
  
      /**
       * 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() == 0 && errorCount() == 0;
     }
 }