KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > junit > framework > TestResult


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