blob: d0f6c8587725df1c140fa397aa590ccfbaf3b801 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
package org.junit.runner.notification;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.junit.internal.AssumptionViolatedException;
import org.junit.runner.Description;
import org.junit.runner.Result;
/**
* If you write custom runners, you may need to notify JUnit of your progress running tests.
* Do this by invoking the <code>RunNotifier</code> passed to your implementation of
* {@link org.junit.runner.Runner#run(RunNotifier)}. Future evolution of this class is likely to
* move {@link #fireTestRunStarted(Description)} and {@link #fireTestRunFinished(Result)}
* to a separate class since they should only be called once per run.
*/
public class RunNotifier {
private final List<RunListener> fListeners=
Collections.synchronizedList(new ArrayList<RunListener>());
private boolean fPleaseStop= false;
/** Internal use only
*/
public void addListener(RunListener listener) {
fListeners.add(listener);
}
/** Internal use only
*/
public void removeListener(RunListener listener) {
fListeners.remove(listener);
}
private abstract class SafeNotifier {
void run() {
synchronized (fListeners) {
for (Iterator<RunListener> all= fListeners.iterator(); all.hasNext();)
try {
notifyListener(all.next());
} catch (Exception e) {
all.remove(); // Remove the offending listener first to avoid an infinite loop
fireTestFailure(new Failure(Description.TEST_MECHANISM, e));
}
}
}
abstract protected void notifyListener(RunListener each) throws Exception;
}
/**
* Do not invoke.
*/
public void fireTestRunStarted(final Description description) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testRunStarted(description);
};
}.run();
}
/**
* Do not invoke.
*/
public void fireTestRunFinished(final Result result) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testRunFinished(result);
};
}.run();
}
/**
* Invoke to tell listeners that an atomic test is about to start.
* @param description the description of the atomic test (generally a class and method name)
* @throws StoppedByUserException thrown if a user has requested that the test run stop
*/
public void fireTestStarted(final Description description) throws StoppedByUserException {
if (fPleaseStop)
throw new StoppedByUserException();
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testStarted(description);
};
}.run();
}
/**
* Invoke to tell listeners that an atomic test failed.
* @param failure the description of the test that failed and the exception thrown
*/
public void fireTestFailure(final Failure failure) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testFailure(failure);
};
}.run();
}
/**
* Invoke to tell listeners that an atomic test flagged that it assumed
* something false.
*
* @param failure
* the description of the test that failed and the
* {@link AssumptionViolatedException} thrown
*/
public void fireTestAssumptionFailed(final Failure failure) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testAssumptionFailure(failure);
};
}.run();
}
/**
* Invoke to tell listeners that an atomic test was ignored.
* @param description the description of the ignored test
*/
public void fireTestIgnored(final Description description) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testIgnored(description);
}
}.run();
}
/**
* Invoke to tell listeners that an atomic test finished. Always invoke
* {@link #fireTestFinished(Description)} if you invoke {@link #fireTestStarted(Description)}
* as listeners are likely to expect them to come in pairs.
* @param description the description of the test that finished
*/
public void fireTestFinished(final Description description) {
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testFinished(description);
};
}.run();
}
/**
* Ask that the tests run stop before starting the next test. Phrased politely because
* the test currently running will not be interrupted. It seems a little odd to put this
* functionality here, but the <code>RunNotifier</code> is the only object guaranteed
* to be shared amongst the many runners involved.
*/
public void pleaseStop() {
fPleaseStop= true;
}
/**
* Internal use only. The Result's listener must be first.
*/
public void addFirstListener(RunListener listener) {
fListeners.add(0, listener);
}
}
|
