Exceptions on other threads will be reported in tests

Anything that uses the GRIPModule will be forced
to use an event bus that will report exceptions.
Also, the thread exceptions will be dumped for other
threads that error durring a given test.

Author: JLLeitschuh

core/src/main/java/edu/wpi/grip/core/GRIPCoreModule.java

@@ -16,6 +16,7 @@
 import edu.wpi.grip.core.sources.MultiImageFileSource;
 import edu.wpi.grip.core.util.ExceptionWitness;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.logging.*;
 
@@ -25,9 +26,9 @@
  */
 @SuppressWarnings("PMD.MoreThanOneLogger")
 public class GRIPCoreModule extends AbstractModule {
-    private final Logger logger = Logger.getLogger(GRIPCoreModule.class.getName());
+    private static final Logger logger = Logger.getLogger(GRIPCoreModule.class.getName());
 
-    private final EventBus eventBus = new EventBus(this::onSubscriberException);
+    private final EventBus eventBus;
 
     // This is in a static initialization block so that we don't create a ton of
     // log files when running tests
@@ -75,7 +76,11 @@ public synchronized void publish(final LogRecord record) {
         }
     }
 
+    /*
+     * This class should not be used in tests. Use GRIPCoreTestModule for tests.
+     */
     public GRIPCoreModule() {
+        this.eventBus = new EventBus(this::onSubscriberException);
         // TODO: HACK! Don't assign the global thread handler to an instance method. Creates global state.
         Thread.setDefaultUncaughtExceptionHandler(this::onThreadException);
     }
@@ -111,7 +116,7 @@ public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
         install(new FactoryModuleBuilder().build(ExceptionWitness.Factory.class));
     }
 
-    private void onSubscriberException(Throwable exception, SubscriberExceptionContext context) {
+    protected void onSubscriberException(Throwable exception, @Nullable SubscriberExceptionContext exceptionContext) {
         if (exception instanceof InterruptedException) {
             logger.log(Level.FINE, "EventBus Subscriber threw InterruptedException", exception);
             Thread.currentThread().interrupt();
@@ -126,7 +131,7 @@ private void onSubscriberException(Throwable exception, SubscriberExceptionConte
      * We drop the last throwable because we clearly have a problem beyond our control.
      */
     @SuppressWarnings({"PMD.AvoidCatchingThrowable", "PMD.EmptyCatchBlock"})
-    private void onThreadException(Thread thread, Throwable exception) {
+    protected void onThreadException(Thread thread, Throwable exception) {
         // Don't do anything outside of a try catch block when dealing with thread death
         try {
             if (exception instanceof Error && !(exception instanceof AssertionError)) {

core/src/main/java/edu/wpi/grip/core/Pipeline.java

@@ -300,6 +300,7 @@ public synchronized void moveStep(Step step, int delta) {
     public void onConnectionAdded(ConnectionAddedEvent event) {
         final Connection connection = event.getConnection();
         this.connections.add(connection);
+        this.eventBus.register(connection);
     }
 
     @Subscribe

core/src/test/java/edu/wpi/grip/core/PipelineTest.java

@@ -7,6 +7,8 @@
 import edu.wpi.grip.core.events.ConnectionRemovedEvent;
 import edu.wpi.grip.core.events.SourceAddedEvent;
 import edu.wpi.grip.core.events.SourceRemovedEvent;
+import edu.wpi.grip.util.GRIPCoreTestModule;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -19,7 +21,7 @@
 
 public class PipelineTest {
 
-    private Injector injector;
+    private GRIPCoreTestModule testModule;
     private Step.Factory stepFactory;
     private EventBus eventBus;
     private Pipeline pipeline;
@@ -38,13 +40,20 @@ public MockConnection(EventBus eventBus, Pipeline pipeline) {
 
     @Before
     public void setUp() {
-        injector = Guice.createInjector(new GRIPCoreModule());
+        testModule = new GRIPCoreTestModule();
+        testModule.setUp();
+        final Injector injector = Guice.createInjector(testModule);
         stepFactory = injector.getInstance(Step.Factory.class);
         eventBus = injector.getInstance(EventBus.class);
         pipeline = injector.getInstance(Pipeline.class);
         addition = new AdditionOperation();
     }
 
+    @After
+    public void tearDown() {
+        testModule.tearDown();
+    }
+
     @Test
     public void testAddSource() throws URISyntaxException, IOException {
         Source source = new MockSource();

core/src/test/java/edu/wpi/grip/core/serialization/CompatibilityTest.java

@@ -3,12 +3,12 @@
 import com.google.common.eventbus.EventBus;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
-import edu.wpi.grip.core.GRIPCoreModule;
 import edu.wpi.grip.core.Pipeline;
 import edu.wpi.grip.core.operations.Operations;
-import edu.wpi.grip.core.settings.ProjectSettings;
 import edu.wpi.grip.generated.CVOperations;
 import edu.wpi.grip.util.Files;
+import edu.wpi.grip.util.GRIPCoreTestModule;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -26,22 +26,19 @@ public class CompatibilityTest {
     private static final URI testphotoURI = Files.testphotoURI; //The location of the photo source for the test
     private static final URI testprojectURI = Files.testprojectURI; //The location of the save file for the test
 
+    private GRIPCoreTestModule testModule;
     private Pipeline pipeline;
-    private Project project;
-    private ProjectSettings settings;
-
-    private EventBus eventBus;
 
     @Before
     public void setUp() throws Exception {
-
+        testModule = new GRIPCoreTestModule();
+        testModule.setUp();
         //Set up the stuff we need for the core functionality for GRIP
-        final Injector injector = Guice.createInjector(new GRIPCoreModule());
+        final Injector injector = Guice.createInjector(testModule);
 
-        eventBus = injector.getInstance(EventBus.class);
+        final EventBus eventBus = injector.getInstance(EventBus.class);
         pipeline = injector.getInstance(Pipeline.class);
-        project = injector.getInstance(Project.class);
-        settings = injector.getInstance(ProjectSettings.class);
+        final Project project = injector.getInstance(Project.class);
 
         //Add the operations so that GRIP will recognize them
         Operations.addOperations(eventBus);
@@ -73,6 +70,11 @@ public void setUp() throws Exception {
         project.open(file);
     }
 
+    @After
+    public void tearDown() {
+        testModule.tearDown();
+    }
+
     @Test
     public void testFoo() throws Exception {
         assertEquals("The expected number of steps were not found", 50, pipeline.getSteps().size());

core/src/test/java/edu/wpi/grip/core/serialization/ProjectTest.java

@@ -14,6 +14,8 @@
 import edu.wpi.grip.core.settings.ProjectSettings;
 import edu.wpi.grip.core.sources.ImageFileSource;
 import edu.wpi.grip.util.Files;
+import edu.wpi.grip.util.GRIPCoreTestModule;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -27,6 +29,7 @@
 
 public class ProjectTest {
 
+    private GRIPCoreTestModule testModule;
     private Connection.Factory<Object> connectionFactory;
     private ImageFileSource.Factory imageSourceFactory;
     private Step.Factory stepFactory;
@@ -40,7 +43,9 @@ public class ProjectTest {
 
     @Before
     public void setUp() throws Exception {
-        final Injector injector = Guice.createInjector(new GRIPCoreModule());
+        testModule = new GRIPCoreTestModule();
+        testModule.setUp();
+        final Injector injector = Guice.createInjector(testModule);
         connectionFactory = injector
                 .getInstance(Key.get(new TypeLiteral<Connection.Factory<Object>>() {
                 }));
@@ -70,6 +75,11 @@ public void setUp() throws Exception {
         eventBus.post(new OperationAddedEvent(opencvAddOperation));
     }
 
+    @After
+    public void tearDown() {
+        testModule.tearDown();
+    }
+
     private void serializeAndDeserialize() {
         final Writer writer = new StringWriter();
         project.save(writer);

core/src/test/java/edu/wpi/grip/core/sources/CameraSourceTest.java

@@ -7,9 +7,9 @@
 import com.google.common.util.concurrent.Service;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
-import edu.wpi.grip.core.GRIPCoreModule;
 import edu.wpi.grip.core.events.UnexpectedThrowableEvent;
 import edu.wpi.grip.core.util.MockExceptionWitness;
+import edu.wpi.grip.util.GRIPCoreTestModule;
 import org.bytedeco.javacpp.indexer.Indexer;
 import org.bytedeco.javacv.Frame;
 import org.bytedeco.javacv.FrameGrabber;
@@ -25,10 +25,8 @@
 import static org.junit.Assert.*;
 
 public class CameraSourceTest {
-    private Injector injector;
+    private GRIPCoreTestModule testModule;
     private CameraSource.Factory cameraSourceFactory;
-
-    private EventBus eventBus;
     private CameraSource cameraSourceWithMockGrabber;
     private MockFrameGrabberFactory mockFrameGrabberFactory;
 
@@ -108,10 +106,12 @@ public FrameGrabber create(String addressProperty) throws MalformedURLException
 
     @Before
     public void setUp() throws Exception {
-        this.injector = Guice.createInjector(new GRIPCoreModule());
+        this.testModule = new GRIPCoreTestModule();
+        testModule.setUp();
+        final Injector injector = Guice.createInjector(testModule);
         this.cameraSourceFactory = injector.getInstance(CameraSource.Factory.class);
 
-        this.eventBus = new EventBus();
+        final EventBus eventBus = new EventBus();
         class UnhandledExceptionWitness {
             @Subscribe
             public void onUnexpectedThrowableEvent(UnexpectedThrowableEvent event) {
@@ -120,7 +120,7 @@ public void onUnexpectedThrowableEvent(UnexpectedThrowableEvent event) {
                 });
             }
         }
-        this.eventBus.register(new UnhandledExceptionWitness());
+        eventBus.register(new UnhandledExceptionWitness());
         this.mockFrameGrabberFactory = new MockFrameGrabberFactory();
         this.cameraSourceWithMockGrabber = new CameraSource(
                 eventBus,
@@ -132,6 +132,7 @@ public void onUnexpectedThrowableEvent(UnexpectedThrowableEvent event) {
     @After
     public void tearDown() throws Exception {
         mockFrameGrabberFactory.frameGrabber.release();
+        testModule.tearDown();
     }
 
     @Test(expected = IOException.class)

core/src/test/java/edu/wpi/grip/util/GRIPCoreTestModule.java

@@ -0,0 +1,114 @@
+package edu.wpi.grip.util;
+
+
+import com.google.common.eventbus.SubscriberExceptionContext;
+import edu.wpi.grip.core.GRIPCoreModule;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * This GRIPCoreTestModule is designed to be used in tests.
+ * Any thread that uses the DefaultUncaughtExceptionHandler will have exceptions
+ * dumped into this class. Exceptions thrown by the event bus will also be
+ * collected using this handler as well.
+ * When {@link #tearDown()} is called the exceptions that have been accrued
+ * during the test will be rethrown. This should be done in a tests
+ * {@link org.junit.After} annotated method.
+ * If tear down is not called and another TestThrowablesHandler is created
+ * this class will throw an assertion error.
+ * This is done to ensure that exceptions always get dumped for the test
+ * that has just run.
+ */
+public class GRIPCoreTestModule extends GRIPCoreModule {
+    private static volatile boolean instanceAlive = false;
+
+    private final ConcurrentLinkedQueue<ThreadThrowablePair> threadExceptions = new ConcurrentLinkedQueue<>();
+    private final ConcurrentLinkedQueue<SubscriberThrowablePair> subscriberExceptions = new ConcurrentLinkedQueue<>();
+    private boolean setUp = false;
+
+    public GRIPCoreTestModule() {
+        super();
+        assert !instanceAlive : "There is a GRIPCoreTestModule that did not have it's `tearDown` method called.";
+    }
+
+    public void setUp() {
+        instanceAlive = true;
+        setUp = true;
+    }
+
+    /**
+     * Rethrows any exceptions that were thrown by other threads or the event bus.
+     * This must be called in the {@link org.junit.After} method for any test that
+     * uses this class. If this is not called then the next test that tries
+     * to use an instance of this class will throw an exception.
+     */
+    public void tearDown() {
+        try {
+            final List<Throwable> throwables = new ArrayList<>(2);
+            if (!threadExceptions.isEmpty()) {
+                throwables.add(MultiException.create(threadExceptions.stream().map(ThreadThrowablePair::getThrowable).collect(Collectors.toList())));
+            }
+            if (!subscriberExceptions.isEmpty()) {
+                throwables.add(MultiException.create(subscriberExceptions.stream().map(SubscriberThrowablePair::getThrowable).collect(Collectors.toList())));
+            }
+            if (!throwables.isEmpty()) {
+                throw MultiException.create(throwables);
+            }
+        } finally {
+            instanceAlive = false;
+        }
+    }
+
+
+    @Override
+    protected void configure() {
+        assert setUp : "The GRIPCoreTestModule handler was not set up. Call 'setUp' before passing the injector";
+        super.configure();
+    }
+
+    @Override
+    protected void onThreadException(Thread thread, Throwable exception) {
+        // Do not call super, we don't want the default functionality
+        threadExceptions.add(new ThreadThrowablePair(thread, exception));
+    }
+
+    @Override
+    protected void onSubscriberException(Throwable exception, SubscriberExceptionContext exceptionContext) {
+        // Do not call super, we don't want the default functionality
+        subscriberExceptions.add(new SubscriberThrowablePair(exception, exceptionContext));
+    }
+
+    private static final class ThreadThrowablePair {
+        private final Thread thread;
+        private final Throwable throwable;
+
+        private ThreadThrowablePair(Thread thread, Throwable throwable) {
+            this.thread = checkNotNull(thread, "Thread cannot be null");
+            this.throwable = checkNotNull(throwable, "Throwable cannot be null");
+        }
+
+        private Throwable getThrowable() {
+            return throwable;
+        }
+    }
+
+    private static final class SubscriberThrowablePair {
+        private final Throwable exception;
+        private final SubscriberExceptionContext exceptionContext;
+
+        private SubscriberThrowablePair(Throwable exception, SubscriberExceptionContext exceptionContext) {
+            this.exception = checkNotNull(exception, "Throwable cannot be null");
+            this.exceptionContext = checkNotNull(exceptionContext, "SubscriberExceptionContext cannot be null");
+        }
+
+        private Throwable getThrowable() {
+            return exception;
+        }
+    }
+
+}