problem to remove synchronized listener

Tibor Digana · Tibor Digana · commit 21a926e47461 · 2013-01-30T20:01:55.000+01:00
diff --git a/pom.xml b/pom.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+﻿<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
@@ -93,6 +93,11 @@
             <artifactId>hamcrest-core</artifactId>
             <version>1.3</version>
         </dependency>
+        <dependency>
+            <groupId>net.jcip</groupId>
+            <artifactId>jcip-annotations</artifactId>
+            <version>1.0</version>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/src/main/java/org/junit/runner/notification/EqualRunListener.java b/src/main/java/org/junit/runner/notification/EqualRunListener.java
@@ -0,0 +1,72 @@
+package org.junit.runner.notification;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+/**
+ * See the equals method.
+ *
+ * @author Tibor Digana (tibor17)
+ * @version 4.12
+ * @since 4.12
+ */
+final class EqualRunListener extends RunListener {
+    private final RunListener listener;
+
+    EqualRunListener(RunListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("null listener");
+        }
+        this.listener = listener;
+    }
+
+    @Override
+    public void testRunStarted(Description description) throws Exception {
+        listener.testRunStarted(description);
+    }
+
+    @Override
+    public void testRunFinished(Result result) throws Exception {
+        listener.testRunFinished(result);
+    }
+
+    @Override
+    public void testStarted(Description description) throws Exception {
+        listener.testStarted(description);
+    }
+
+    @Override
+    public void testFinished(Description description) throws Exception {
+        listener.testFinished(description);
+    }
+
+    @Override
+    public void testFailure(Failure failure) throws Exception {
+        listener.testFailure(failure);
+    }
+
+    @Override
+    public void testAssumptionFailure(Failure failure) {
+        listener.testAssumptionFailure(failure);
+    }
+
+    @Override
+    public void testIgnored(Description description) throws Exception {
+        listener.testIgnored(description);
+    }
+
+    @Override
+    public int hashCode() {
+        return listener.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o != null && o.equals(listener);
+    }
+
+    @Override
+    public String toString() {
+        return listener.toString();
+    }
+}
diff --git a/src/main/java/org/junit/runner/notification/RunNotifier.java b/src/main/java/org/junit/runner/notification/RunNotifier.java
@@ -1,13 +1,15 @@
 package org.junit.runner.notification;
 
+import net.jcip.annotations.ThreadSafe;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
-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.
@@ -26,16 +28,23 @@ public class RunNotifier {
      * Internal use only
      */
     public void addListener(RunListener listener) {
+        listener = wrapSynchronizedIfNotThreadSafe(listener);
         fListeners.add(listener);
     }
 
     /**
      * Internal use only
      */
     public void removeListener(RunListener listener) {
+        listener = new EqualRunListener(listener);
         fListeners.remove(listener);
     }
 
+    private static RunListener wrapSynchronizedIfNotThreadSafe(RunListener listener) {
+        boolean isThreadSafe = listener.getClass().isAnnotationPresent(ThreadSafe.class);
+        return isThreadSafe ? new EqualRunListener(listener) : new SynchronizedRunListener(listener);
+    }
+
     private abstract class SafeNotifier {
         private final Collection<RunListener> fCurrentListeners;
 
diff --git a/src/main/java/org/junit/runner/notification/SynchronizedRunListener.java b/src/main/java/org/junit/runner/notification/SynchronizedRunListener.java
@@ -0,0 +1,73 @@
+package org.junit.runner.notification;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+/**
+ * SynchronizedRunListener decorates {@link RunListener} and
+ * has all methods synchronized.
+ *
+ * @author Tibor Digana (tibor17)
+ * @version 4.12
+ * @since 4.12
+ */
+final class SynchronizedRunListener extends RunListener {
+    private final RunListener listener;
+
+    SynchronizedRunListener(RunListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("null listener");
+        }
+        this.listener = listener;
+    }
+
+    @Override
+    public synchronized void testRunStarted(Description description) throws Exception {
+        listener.testRunStarted(description);
+    }
+
+    @Override
+    public synchronized void testRunFinished(Result result) throws Exception {
+        listener.testRunFinished(result);
+    }
+
+    @Override
+    public synchronized void testStarted(Description description) throws Exception {
+        listener.testStarted(description);
+    }
+
+    @Override
+    public synchronized void testFinished(Description description) throws Exception {
+        listener.testFinished(description);
+    }
+
+    @Override
+    public synchronized void testFailure(Failure failure) throws Exception {
+        listener.testFailure(failure);
+    }
+
+    @Override
+    public synchronized void testAssumptionFailure(Failure failure) {
+        listener.testAssumptionFailure(failure);
+    }
+
+    @Override
+    public synchronized void testIgnored(Description description) throws Exception {
+        listener.testIgnored(description);
+    }
+
+    @Override
+    public int hashCode() {
+        return listener.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return listener.equals(o);
+    }
+
+    @Override
+    public String toString() {
+        return listener.toString();
+    }
+}
diff --git a/src/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java b/src/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java
@@ -1,16 +1,13 @@
 package org.junit.runner.notification;
 
-import java.util.concurrent.BrokenBarrierException;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CyclicBarrier;
-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 net.jcip.annotations.ThreadSafe;
 import org.junit.Test;
 import org.junit.runner.Description;
 
+import java.util.concurrent.*;
+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;
@@ -177,6 +174,74 @@ public Object call() throws Exception {
         }
     }
 
+    @Test
+    public void keepContractOnEqualsNegative() {
+        RunNotifier notifier = new RunNotifier();
+        final ConcurrentRunListener listener = new ConcurrentRunListener();
+        ConcurrentRunListener wrappedListener = new ConcurrentRunListener() {
+            @Override
+            public boolean equals(Object o) {
+                return listener.equals(o);
+            }
+        };
+        notifier.addListener(wrappedListener);
+        assertThat(wrappedListener.testStarted.get(), is(0));
+        notifier.fireTestStarted(null);
+        assertThat(wrappedListener.testStarted.get(), is(1));
+        notifier.removeListener(listener);
+        notifier.fireTestStarted(null);
+        assertThat(wrappedListener.testStarted.get(), is(2));
+    }
+
+    @Test
+    public void keepContractOnEquals() {
+        RunNotifier notifier = new RunNotifier();
+        final ConcurrentRunListener listener = new ConcurrentRunListener();
+        ConcurrentRunListener wrappedListener = new ConcurrentRunListener() {
+            @Override
+            public boolean equals(Object o) {
+                return listener.equals(o);
+            }
+        };
+        notifier.addListener(listener);
+        assertThat(listener.testStarted.get(), is(0));
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+        notifier.removeListener(wrappedListener);
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+    }
+
+    @Test
+    public void wrapSynchronizedIfNotThreadSafe() {
+        RunNotifier notifier = new RunNotifier();
+        ConcurrentRunListener listener = new ConcurrentRunListener();
+        notifier.addListener(listener);
+        assertThat(listener.testStarted.get(), is(0));
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+        notifier.removeListener(listener);
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+    }
+
+    @ThreadSafe
+    private static class ThreadSafeRunListener extends ConcurrentRunListener {
+    }
+
+    @Test
+    public void doNotWrapIfThreadSafe() {
+        RunNotifier notifier = new RunNotifier();
+        ThreadSafeRunListener listener = new ThreadSafeRunListener();
+        notifier.addListener(listener);
+        assertThat(listener.testStarted.get(), is(0));
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+        notifier.removeListener(listener);
+        notifier.fireTestStarted(null);
+        assertThat(listener.testStarted.get(), is(1));
+    }
+
     private static int countReportedTestFailures(ExaminedListener[] listeners) {
         int count = 0;
         for (ExaminedListener listener : listeners) {
