View Javadoc

1   package junit.framework;
2   
3   import java.util.Vector;
4   import java.util.Enumeration;
5   
6   /***
7    * A <code>TestResult</code> collects the results of executing
8    * a test case. It is an instance of the Collecting Parameter pattern.
9    * The test framework distinguishes between <i>failures</i> and <i>errors</i>.
10   * A failure is anticipated and checked for with assertions. Errors are
11   * unanticipated problems like an <code>ArrayIndexOutOfBoundsException</code>.
12   *
13   * @see Test
14   */
15  public class TestResult extends Object {
16  	protected Vector fFailures;
17  	protected Vector fErrors;
18  	protected Vector fListeners;
19  	protected int fRunTests;
20  	private boolean fStop;
21  	
22  	public TestResult() {
23  		fFailures= new Vector();
24  		fErrors= new Vector();
25  		fListeners= new Vector();
26  		fRunTests= 0;
27  		fStop= false;
28  	}
29  	/***
30  	 * Adds an error to the list of errors. The passed in exception
31  	 * caused the error.
32  	 */
33  	public synchronized void addError(Test test, Throwable t) {
34  		fErrors.addElement(new TestFailure(test, t));
35  		for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
36  			((TestListener)e.nextElement()).addError(test, t);
37  		}
38  	}
39  	/***
40  	 * Adds a failure to the list of failures. The passed in exception
41  	 * caused the failure.
42  	 */
43  	public synchronized void addFailure(Test test, AssertionFailedError t) {
44  		fFailures.addElement(new TestFailure(test, t));
45  		for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
46  			((TestListener)e.nextElement()).addFailure(test, t);
47  		}
48  	}
49  	/***
50  	 * Registers a TestListener
51  	 */
52  	public synchronized void addListener(TestListener listener) {
53  		fListeners.addElement(listener);
54  	}
55  	/***
56  	 * Unregisters a TestListener
57  	 */
58  	public synchronized void removeListener(TestListener listener) {
59  		fListeners.removeElement(listener);
60  	}
61  	/***
62  	 * Returns a copy of the listeners.
63  	 */
64  	private synchronized Vector cloneListeners() {
65  		return (Vector)fListeners.clone();
66  	}
67  	/***
68  	 * Informs the result that a test was completed.
69  	 */
70  	public void endTest(Test test) {
71  		for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
72  			((TestListener)e.nextElement()).endTest(test);
73  		}
74  	}
75  	/***
76  	 * Gets the number of detected errors.
77  	 */
78  	public synchronized int errorCount() {
79  		return fErrors.size();
80  	}
81  	/***
82  	 * Returns an Enumeration for the errors
83  	 */
84  	public synchronized Enumeration errors() {
85  		return fErrors.elements();
86  	}
87  	/***
88  	 * Gets the number of detected failures.
89  	 */
90  	public synchronized int failureCount() {
91  		return fFailures.size();
92  	}
93  	/***
94  	 * Returns an Enumeration for the failures
95  	 */
96  	public synchronized Enumeration failures() {
97  		return fFailures.elements();
98  	}
99  	/***
100 	 * Runs a TestCase.
101 	 */
102 	protected void run(final TestCase test) {
103 		startTest(test);
104 		Protectable p= new Protectable() {
105 			public void protect() throws Throwable {
106 				test.runBare();
107 			}
108 		};
109 		runProtected(test, p);
110 
111 		endTest(test);
112 	}
113 	/***
114 	 * Gets the number of run tests.
115 	 */
116 	public synchronized int runCount() {
117 		return fRunTests;
118 	}
119 	/***
120 	 * Runs a TestCase.
121 	 */
122 	public void runProtected(final Test test, Protectable p) {
123 		try {
124 			p.protect();
125 		} 
126 		catch (AssertionFailedError e) {
127 			addFailure(test, e);
128 		}
129 		catch (ThreadDeath e) { // don't catch ThreadDeath by accident
130 			throw e;
131 		}
132 		catch (Throwable e) {
133 			addError(test, e);
134 		}
135 	}
136 	/***
137 	 * Checks whether the test run should stop
138 	 */
139 	public synchronized boolean shouldStop() {
140 		return fStop;
141 	}
142 	/***
143 	 * Informs the result that a test will be started.
144 	 */
145 	public void startTest(Test test) {
146 		final int count= test.countTestCases();
147 		synchronized(this) {
148 			fRunTests+= count;
149 		}
150 		for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
151 			((TestListener)e.nextElement()).startTest(test);
152 		}
153 	}
154 	/***
155 	 * Marks that the test run should stop.
156 	 */
157 	public synchronized void stop() {
158 		fStop= true;
159 	}
160 	/***
161 	 * Returns whether the entire test was successful or not.
162 	 */
163 	public synchronized boolean wasSuccessful() {
164 		return failureCount() == 0 && errorCount() == 0;
165 	}
166 }