Use EventCollecter if possible.

Avoids duplicate implementations of RunListener for different test and
provides Hamcrest matchers for verifying events sent to the listener.

Author: stefanbirkner

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

@@ -1,20 +1,20 @@
 package org.junit.runner;
 
-import java.util.HashSet;
-import java.util.Set;
-
+import org.hamcrest.Matcher;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.experimental.categories.ExcludeCategories;
 import org.junit.experimental.categories.IncludeCategories;
-import org.junit.runner.notification.RunListener;
 import org.junit.tests.TestSystem;
+import org.junit.testsupport.EventCollector;
 
+import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.testsupport.EventCollectorMatchers.hasTestFinished;
+import static org.junit.testsupport.EventCollectorMatchers.hasTestStarted;
 
 public class FilterOptionIntegrationTest {
     private static final String INCLUDES_DUMMY_CATEGORY_0 = "--filter=" +
@@ -23,7 +23,7 @@ public class FilterOptionIntegrationTest {
             ExcludeCategories.class.getName() + "=" + DummyCategory1.class.getName();
 
     private JUnitCore jUnitCore = new JUnitCore();
-    private TestListener testListener = new TestListener();
+    private EventCollector testListener = new EventCollector();
 
     @Before
     public void setUp() {
@@ -111,40 +111,15 @@ private Result runJUnit(final String... args) {
     }
 
     private void assertWasRun(Class<?> testClass) {
-        assertTrue(testClass.getName() + " expected to finish but did not", testListener.wasRun(testClass));
+        assertThat(testListener, wasRun(testClass));
     }
 
     private void assertWasNotRun(Class<?> testClass) {
-        assertFalse(
-                testClass.getName() + " expected not to have been started but was",
-                testListener.wasRun(testClass));
+        assertThat(testListener, not(wasRun(testClass)));
     }
 
-    private static class TestListener extends RunListener {
-        private Set<String> startedTests = new HashSet<String>();
-        private Set<String> finishedTests = new HashSet<String>();
-
-        @Override
-        public void testFinished(final Description description) {
-            finishedTests.add(description.getClassName());
-        }
-
-        private boolean testFinished(final Class<?> testClass) {
-            return finishedTests.contains(testClass.getName());
-        }
-
-        @Override
-        public void testStarted(final Description description) {
-            startedTests.add(description.getClassName());
-        }
-
-        private boolean testStarted(final Class<?> testClass) {
-            return startedTests.contains(testClass.getName());
-        }
-
-        public boolean wasRun(final Class<?> testClass) {
-            return testStarted(testClass) && testFinished(testClass);
-        }
+    private Matcher<EventCollector> wasRun(Class<?> testClass) {
+        return allOf(hasTestStarted(testClass), hasTestFinished(testClass));
     }
 
     public static class DummyTestClass {

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

@@ -1,21 +1,22 @@
 package org.junit.runner.notification;
 
-import org.junit.Test;
-import org.junit.runner.Description;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.testsupport.EventCollectorMatchers.hasNumberOfTestsStarted;
 
 import java.util.Random;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.testsupport.EventCollector;
 
 /**
  * Testing RunNotifier in concurrent access.
@@ -26,21 +27,13 @@
  */
 public final class ConcurrentRunNotifierTest {
     private static final long TIMEOUT = 3;
-    private final RunNotifier fNotifier = new RunNotifier();
 
-    private static class ConcurrentRunListener extends RunListener {
-        final AtomicInteger fTestStarted = new AtomicInteger(0);
-
-        @Override
-        public void testStarted(Description description) throws Exception {
-            fTestStarted.incrementAndGet();
-        }
-    }
+    private final RunNotifier fNotifier = new RunNotifier();
 
     @Test
     public void realUsage() throws Exception {
-        ConcurrentRunListener listener1 = new ConcurrentRunListener();
-        ConcurrentRunListener listener2 = new ConcurrentRunListener();
+        EventCollector listener1 = new EventCollector();
+        EventCollector listener2 = new EventCollector();
         fNotifier.addListener(listener1);
         fNotifier.addListener(listener2);
 
@@ -59,8 +52,8 @@ public void run() {
         fNotifier.removeListener(listener1);
         fNotifier.removeListener(listener2);
 
-        assertThat(listener1.fTestStarted.get(), is(numParallelTests));
-        assertThat(listener2.fTestStarted.get(), is(numParallelTests));
+        assertThat(listener1, hasNumberOfTestsStarted(numParallelTests));
+        assertThat(listener2, hasNumberOfTestsStarted(numParallelTests));
     }
 
     private static class ExaminedListener extends RunListener {

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

@@ -1,34 +1,31 @@
 package org.junit.runner.notification;
 
 import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertNotNull;
+import static org.hamcrest.CoreMatchers.not;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
+import static org.junit.testsupport.EventCollectorMatchers.hasNoFailure;
+import static org.junit.testsupport.EventCollectorMatchers.hasNumberOfTestsStarted;
 import org.junit.Test;
-import org.junit.runner.Description;
 import org.junit.runner.Result;
+import org.junit.testsupport.EventCollector;
 
 public class RunNotifierTest {
     private final RunNotifier fNotifier = new RunNotifier();
 
     @Test
     public void notifiesSecondListenerIfFirstThrowsException() {
-        FailureListener failureListener = new FailureListener();
+        EventCollector eventCollector = new EventCollector();
         fNotifier.addListener(new CorruptListener());
-        fNotifier.addListener(failureListener);
+        fNotifier.addListener(eventCollector);
         fNotifier.fireTestFailure(new Failure(null, null));
-        assertNotNull("The FailureListener registered no failure.",
-                failureListener.failure);
+        assertThat(eventCollector, not(hasNoFailure()));
     }
 
     @Test
     public void hasNoProblemsWithFailingListeners() { // see issues 209 and 395
         fNotifier.addListener(new CorruptListener());
-        fNotifier.addListener(new FailureListener());
+        fNotifier.addListener(new EventCollector());
         fNotifier.addListener(new CorruptListener());
         fNotifier.fireTestRunFinished(new Result());
     }
@@ -44,88 +41,70 @@ public void testFailure(Failure failure) throws Exception {
             throw new RuntimeException();
         }
     }
-    
+
     @Test
     public void addAndRemoveWithNonThreadSafeListener() {
-        CountingListener listener = new CountingListener();
-        assertThat(listener.fTestStarted.get(), is(0));
+        EventCollector listener = new EventCollector();
+        assertThat(listener, hasNumberOfTestsStarted(0));
         fNotifier.addListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
         fNotifier.removeListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
     }
 
     @Test
     public void addFirstAndRemoveWithNonThreadSafeListener() {
-        CountingListener listener = new CountingListener();
-        assertThat(listener.fTestStarted.get(), is(0));
+        EventCollector listener = new EventCollector();
+        assertThat(listener, hasNumberOfTestsStarted(0));
         fNotifier.addFirstListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
         fNotifier.removeListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
     }
-    
+
     @Test
     public void addAndRemoveWithThreadSafeListener() {
         ThreadSafeListener listener = new ThreadSafeListener();
-        assertThat(listener.fTestStarted.get(), is(0));
+        assertThat(listener, hasNumberOfTestsStarted(0));
         fNotifier.addListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
         fNotifier.removeListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
     }
 
     @Test
     public void addFirstAndRemoveWithThreadSafeListener() {
         ThreadSafeListener listener = new ThreadSafeListener();
-        assertThat(listener.fTestStarted.get(), is(0));
+        assertThat(listener, hasNumberOfTestsStarted(0));
         fNotifier.addFirstListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
         fNotifier.removeListener(listener);
         fNotifier.fireTestStarted(null);
-        assertThat(listener.fTestStarted.get(), is(1));
+        assertThat(listener, hasNumberOfTestsStarted(1));
     }
 
     @Test
     public void wrapIfNotThreadSafeShouldNotWrapThreadSafeListeners() {
-        ThreadSafeListener listener = new ThreadSafeListener();;
+        ThreadSafeListener listener = new ThreadSafeListener();
         assertSame(listener, new RunNotifier().wrapIfNotThreadSafe(listener));
     }
 
     @Test
     public void wrapIfNotThreadSafeShouldWrapNonThreadSafeListeners() {
-        CountingListener listener = new CountingListener();
+        EventCollector listener = new EventCollector();
         RunListener wrappedListener = new RunNotifier().wrapIfNotThreadSafe(listener);
         assertThat(wrappedListener, instanceOf(SynchronizedRunListener.class));
     }
 
-    private static class FailureListener extends RunListener {
-        private Failure failure;
-
-        @Override
-        public void testFailure(Failure failure) throws Exception {
-            this.failure = failure;
-        }
-    }
-    
-    private static class CountingListener extends RunListener {
-        final AtomicInteger fTestStarted = new AtomicInteger(0);
-
-        @Override
-        public void testStarted(Description description) throws Exception {
-            fTestStarted.incrementAndGet();
-        }
-    }
-    
     @RunListener.ThreadSafe
-    private static class ThreadSafeListener extends CountingListener {
+    private static class ThreadSafeListener extends EventCollector {
     }
 
 }