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() == 0 && errorCount() == 0;

	}

}