Skip to content

Commit f37aabe

Browse files
stefanbirknerstefanbirkner
committed
Use EventCollecter if possible.
Avoids duplicate implementations of RunListener for different test and provides Hamcrest matchers for verifying events sent to the listener.
1 parent b03c6a5 commit f37aabe

12 files changed

+540
-464
lines changed

‎src/test/java/org/junit/runner/FilterOptionIntegrationTest.java

+11-36
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,20 @@
11
package org.junit.runner;
22

3-
import java.util.HashSet;
4-
import java.util.Set;
5-
3+
import org.hamcrest.Matcher;
64
import org.junit.Before;
75
import org.junit.Test;
86
import org.junit.experimental.categories.Category;
97
import org.junit.experimental.categories.ExcludeCategories;
108
import org.junit.experimental.categories.IncludeCategories;
11-
import org.junit.runner.notification.RunListener;
129
import org.junit.tests.TestSystem;
10+
import org.junit.testsupport.EventCollector;
1311

12+
import static org.hamcrest.CoreMatchers.allOf;
1413
import static org.hamcrest.CoreMatchers.is;
14+
import static org.hamcrest.CoreMatchers.not;
1515
import static org.hamcrest.MatcherAssert.assertThat;
16-
import static org.junit.Assert.assertFalse;
17-
import static org.junit.Assert.assertTrue;
16+
import static org.junit.testsupport.EventCollectorMatchers.hasTestFinished;
17+
import static org.junit.testsupport.EventCollectorMatchers.hasTestStarted;
1818

1919
public class FilterOptionIntegrationTest {
2020
private static final String INCLUDES_DUMMY_CATEGORY_0 = "--filter=" +
@@ -23,7 +23,7 @@ public class FilterOptionIntegrationTest {
2323
ExcludeCategories.class.getName() + "=" + DummyCategory1.class.getName();
2424

2525
private JUnitCore jUnitCore = new JUnitCore();
26-
private TestListener testListener = new TestListener();
26+
private EventCollector testListener = new EventCollector();
2727

2828
@Before
2929
public void setUp() {
@@ -111,40 +111,15 @@ private Result runJUnit(final String... args) {
111111
}
112112

113113
private void assertWasRun(Class<?> testClass) {
114-
assertTrue(testClass.getName() + " expected to finish but did not", testListener.wasRun(testClass));
114+
assertThat(testListener, wasRun(testClass));
115115
}
116116

117117
private void assertWasNotRun(Class<?> testClass) {
118-
assertFalse(
119-
testClass.getName() + " expected not to have been started but was",
120-
testListener.wasRun(testClass));
118+
assertThat(testListener, not(wasRun(testClass)));
121119
}
122120

123-
private static class TestListener extends RunListener {
124-
private Set<String> startedTests = new HashSet<String>();
125-
private Set<String> finishedTests = new HashSet<String>();
126-
127-
@Override
128-
public void testFinished(final Description description) {
129-
finishedTests.add(description.getClassName());
130-
}
131-
132-
private boolean testFinished(final Class<?> testClass) {
133-
return finishedTests.contains(testClass.getName());
134-
}
135-
136-
@Override
137-
public void testStarted(final Description description) {
138-
startedTests.add(description.getClassName());
139-
}
140-
141-
private boolean testStarted(final Class<?> testClass) {
142-
return startedTests.contains(testClass.getName());
143-
}
144-
145-
public boolean wasRun(final Class<?> testClass) {
146-
return testStarted(testClass) && testFinished(testClass);
147-
}
121+
private Matcher<EventCollector> wasRun(Class<?> testClass) {
122+
return allOf(hasTestStarted(testClass), hasTestFinished(testClass));
148123
}
149124

150125
public static class DummyTestClass {

‎src/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java

+13-20
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,22 @@
11
package org.junit.runner.notification;
22

3-
import org.junit.Test;
4-
import org.junit.runner.Description;
3+
import static org.hamcrest.core.Is.is;
4+
import static org.junit.Assert.assertThat;
5+
import static org.junit.Assert.assertTrue;
6+
import static org.junit.testsupport.EventCollectorMatchers.hasNumberOfTestsStarted;
57

68
import java.util.Random;
79
import java.util.concurrent.Callable;
810
import java.util.concurrent.CountDownLatch;
911
import java.util.concurrent.CyclicBarrier;
10-
import java.util.concurrent.Executors;
1112
import java.util.concurrent.ExecutorService;
13+
import java.util.concurrent.Executors;
1214
import java.util.concurrent.TimeUnit;
1315
import java.util.concurrent.atomic.AtomicBoolean;
14-
import java.util.concurrent.atomic.AtomicInteger;
1516

16-
import static org.hamcrest.core.Is.is;
17-
import static org.junit.Assert.assertThat;
18-
import static org.junit.Assert.assertTrue;
17+
import org.junit.Test;
18+
import org.junit.runner.Description;
19+
import org.junit.testsupport.EventCollector;
1920

2021
/**
2122
* Testing RunNotifier in concurrent access.
@@ -26,21 +27,13 @@
2627
*/
2728
public final class ConcurrentRunNotifierTest {
2829
private static final long TIMEOUT = 3;
29-
private final RunNotifier fNotifier = new RunNotifier();
3030

31-
private static class ConcurrentRunListener extends RunListener {
32-
final AtomicInteger fTestStarted = new AtomicInteger(0);
33-
34-
@Override
35-
public void testStarted(Description description) throws Exception {
36-
fTestStarted.incrementAndGet();
37-
}
38-
}
31+
private final RunNotifier fNotifier = new RunNotifier();
3932

4033
@Test
4134
public void realUsage() throws Exception {
42-
ConcurrentRunListener listener1 = new ConcurrentRunListener();
43-
ConcurrentRunListener listener2 = new ConcurrentRunListener();
35+
EventCollector listener1 = new EventCollector();
36+
EventCollector listener2 = new EventCollector();
4437
fNotifier.addListener(listener1);
4538
fNotifier.addListener(listener2);
4639

@@ -59,8 +52,8 @@ public void run() {
5952
fNotifier.removeListener(listener1);
6053
fNotifier.removeListener(listener2);
6154

62-
assertThat(listener1.fTestStarted.get(), is(numParallelTests));
63-
assertThat(listener2.fTestStarted.get(), is(numParallelTests));
55+
assertThat(listener1, hasNumberOfTestsStarted(numParallelTests));
56+
assertThat(listener2, hasNumberOfTestsStarted(numParallelTests));
6457
}
6558

6659
private static class ExaminedListener extends RunListener {

‎src/test/java/org/junit/runner/notification/RunNotifierTest.java

+27-48
Original file line numberDiff line numberDiff line change
@@ -1,34 +1,31 @@
11
package org.junit.runner.notification;
22

33
import static org.hamcrest.CoreMatchers.instanceOf;
4-
import static org.hamcrest.core.Is.is;
5-
import static org.junit.Assert.assertNotNull;
4+
import static org.hamcrest.CoreMatchers.not;
65
import static org.junit.Assert.assertSame;
76
import static org.junit.Assert.assertThat;
8-
9-
import java.util.concurrent.atomic.AtomicInteger;
10-
7+
import static org.junit.testsupport.EventCollectorMatchers.hasNoFailure;
8+
import static org.junit.testsupport.EventCollectorMatchers.hasNumberOfTestsStarted;
119
import org.junit.Test;
12-
import org.junit.runner.Description;
1310
import org.junit.runner.Result;
11+
import org.junit.testsupport.EventCollector;
1412

1513
public class RunNotifierTest {
1614
private final RunNotifier fNotifier = new RunNotifier();
1715

1816
@Test
1917
public void notifiesSecondListenerIfFirstThrowsException() {
20-
FailureListener failureListener = new FailureListener();
18+
EventCollector eventCollector = new EventCollector();
2119
fNotifier.addListener(new CorruptListener());
22-
fNotifier.addListener(failureListener);
20+
fNotifier.addListener(eventCollector);
2321
fNotifier.fireTestFailure(new Failure(null, null));
24-
assertNotNull("The FailureListener registered no failure.",
25-
failureListener.failure);
22+
assertThat(eventCollector, not(hasNoFailure()));
2623
}
2724

2825
@Test
2926
public void hasNoProblemsWithFailingListeners() { // see issues 209 and 395
3027
fNotifier.addListener(new CorruptListener());
31-
fNotifier.addListener(new FailureListener());
28+
fNotifier.addListener(new EventCollector());
3229
fNotifier.addListener(new CorruptListener());
3330
fNotifier.fireTestRunFinished(new Result());
3431
}
@@ -44,88 +41,70 @@ public void testFailure(Failure failure) throws Exception {
4441
throw new RuntimeException();
4542
}
4643
}
47-
44+
4845
@Test
4946
public void addAndRemoveWithNonThreadSafeListener() {
50-
CountingListener listener = new CountingListener();
51-
assertThat(listener.fTestStarted.get(), is(0));
47+
EventCollector listener = new EventCollector();
48+
assertThat(listener, hasNumberOfTestsStarted(0));
5249
fNotifier.addListener(listener);
5350
fNotifier.fireTestStarted(null);
54-
assertThat(listener.fTestStarted.get(), is(1));
51+
assertThat(listener, hasNumberOfTestsStarted(1));
5552
fNotifier.removeListener(listener);
5653
fNotifier.fireTestStarted(null);
57-
assertThat(listener.fTestStarted.get(), is(1));
54+
assertThat(listener, hasNumberOfTestsStarted(1));
5855
}
5956

6057
@Test
6158
public void addFirstAndRemoveWithNonThreadSafeListener() {
62-
CountingListener listener = new CountingListener();
63-
assertThat(listener.fTestStarted.get(), is(0));
59+
EventCollector listener = new EventCollector();
60+
assertThat(listener, hasNumberOfTestsStarted(0));
6461
fNotifier.addFirstListener(listener);
6562
fNotifier.fireTestStarted(null);
66-
assertThat(listener.fTestStarted.get(), is(1));
63+
assertThat(listener, hasNumberOfTestsStarted(1));
6764
fNotifier.removeListener(listener);
6865
fNotifier.fireTestStarted(null);
69-
assertThat(listener.fTestStarted.get(), is(1));
66+
assertThat(listener, hasNumberOfTestsStarted(1));
7067
}
71-
68+
7269
@Test
7370
public void addAndRemoveWithThreadSafeListener() {
7471
ThreadSafeListener listener = new ThreadSafeListener();
75-
assertThat(listener.fTestStarted.get(), is(0));
72+
assertThat(listener, hasNumberOfTestsStarted(0));
7673
fNotifier.addListener(listener);
7774
fNotifier.fireTestStarted(null);
78-
assertThat(listener.fTestStarted.get(), is(1));
75+
assertThat(listener, hasNumberOfTestsStarted(1));
7976
fNotifier.removeListener(listener);
8077
fNotifier.fireTestStarted(null);
81-
assertThat(listener.fTestStarted.get(), is(1));
78+
assertThat(listener, hasNumberOfTestsStarted(1));
8279
}
8380

8481
@Test
8582
public void addFirstAndRemoveWithThreadSafeListener() {
8683
ThreadSafeListener listener = new ThreadSafeListener();
87-
assertThat(listener.fTestStarted.get(), is(0));
84+
assertThat(listener, hasNumberOfTestsStarted(0));
8885
fNotifier.addFirstListener(listener);
8986
fNotifier.fireTestStarted(null);
90-
assertThat(listener.fTestStarted.get(), is(1));
87+
assertThat(listener, hasNumberOfTestsStarted(1));
9188
fNotifier.removeListener(listener);
9289
fNotifier.fireTestStarted(null);
93-
assertThat(listener.fTestStarted.get(), is(1));
90+
assertThat(listener, hasNumberOfTestsStarted(1));
9491
}
9592

9693
@Test
9794
public void wrapIfNotThreadSafeShouldNotWrapThreadSafeListeners() {
98-
ThreadSafeListener listener = new ThreadSafeListener();;
95+
ThreadSafeListener listener = new ThreadSafeListener();
9996
assertSame(listener, new RunNotifier().wrapIfNotThreadSafe(listener));
10097
}
10198

10299
@Test
103100
public void wrapIfNotThreadSafeShouldWrapNonThreadSafeListeners() {
104-
CountingListener listener = new CountingListener();
101+
EventCollector listener = new EventCollector();
105102
RunListener wrappedListener = new RunNotifier().wrapIfNotThreadSafe(listener);
106103
assertThat(wrappedListener, instanceOf(SynchronizedRunListener.class));
107104
}
108105

109-
private static class FailureListener extends RunListener {
110-
private Failure failure;
111-
112-
@Override
113-
public void testFailure(Failure failure) throws Exception {
114-
this.failure = failure;
115-
}
116-
}
117-
118-
private static class CountingListener extends RunListener {
119-
final AtomicInteger fTestStarted = new AtomicInteger(0);
120-
121-
@Override
122-
public void testStarted(Description description) throws Exception {
123-
fTestStarted.incrementAndGet();
124-
}
125-
}
126-
127106
@RunListener.ThreadSafe
128-
private static class ThreadSafeListener extends CountingListener {
107+
private static class ThreadSafeListener extends EventCollector {
129108
}
130109

131110
}

0 commit comments

Comments
 (0)