Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/AsyncEventBusTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/AsyncEventBusTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/AsyncEventBusTest.java (revision 36064) @@ -17,6 +17,6 @@ package org.openstreetmap.josm.eventbus; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; @@ -24,7 +24,6 @@ import java.util.concurrent.Executor; -import org.junit.Before; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.AsyncEventBus; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** @@ -33,5 +32,5 @@ * @author Cliff Biffle */ -public class AsyncEventBusTest { +class AsyncEventBusTest { private static final String EVENT = "Hello"; @@ -41,6 +40,6 @@ private AsyncEventBus bus; - @Before - public void setUp() throws Exception { + @BeforeEach + void setUp() { executor = new FakeExecutor(); bus = new AsyncEventBus(executor); @@ -48,5 +47,5 @@ @Test - public void testBasicDistribution() { + void testBasicDistribution() { StringCatcher catcher = new StringCatcher(); bus.register(catcher); @@ -56,14 +55,14 @@ List events = catcher.getEvents(); - assertTrue("No events should be delivered synchronously.", events.isEmpty()); + assertTrue(events.isEmpty(), "No events should be delivered synchronously."); // Now we find the task in our Executor and explicitly activate it. List tasks = executor.getTasks(); - assertEquals("One event dispatch task should be queued.", 1, tasks.size()); + assertEquals(1, tasks.size(), "One event dispatch task should be queued."); tasks.get(0).run(); - assertEquals("One event should be delivered.", 1, events.size()); - assertEquals("Correct string should be delivered.", EVENT, events.get(0)); + assertEquals(1, events.size(), "One event should be delivered."); + assertEquals(EVENT, events.get(0), "Correct string should be delivered."); } Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/DispatcherTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/DispatcherTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/DispatcherTest.java (revision 36064) @@ -27,10 +27,6 @@ import java.util.concurrent.CyclicBarrier; -import org.junit.Ignore; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.Dispatcher; -import org.openstreetmap.josm.eventbus.EventBus; -import org.openstreetmap.josm.eventbus.Subscribe; -import org.openstreetmap.josm.eventbus.Subscriber; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; /** @@ -40,5 +36,5 @@ */ -public class DispatcherTest { +class DispatcherTest { private final EventBus bus = new EventBus(); @@ -66,6 +62,6 @@ @Test - @Ignore("FIXME") - public void testPerThreadQueuedDispatcher() { + @Disabled("FIXME") + void testPerThreadQueuedDispatcher() { dispatcher = Dispatcher.perThreadDispatchQueue(); dispatcher.dispatch(1, integerSubscribers.iterator()); @@ -87,6 +83,6 @@ @Test - @Ignore("FIXME") - public void testLegacyAsyncDispatcher() { + @Disabled("FIXME") + void testLegacyAsyncDispatcher() { dispatcher = Dispatcher.legacyAsync(); @@ -95,32 +91,26 @@ new Thread( - new Runnable() { - @Override - public void run() { - try { - barrier.await(); - } catch (Exception e) { - throw new AssertionError(e); - } + () -> { + try { + barrier.await(); + } catch (Exception e) { + throw new AssertionError(e); + } - dispatcher.dispatch(2, integerSubscribers.iterator()); - latch.countDown(); - } + dispatcher.dispatch(2, integerSubscribers.iterator()); + latch.countDown(); }) .start(); new Thread( - new Runnable() { - @Override - public void run() { - try { - barrier.await(); - } catch (Exception e) { - throw new AssertionError(e); - } + () -> { + try { + barrier.await(); + } catch (Exception e) { + throw new AssertionError(e); + } - dispatcher.dispatch("foo", stringSubscribers.iterator()); - latch.countDown(); - } + dispatcher.dispatch("foo", stringSubscribers.iterator()); + latch.countDown(); }) .start(); @@ -135,6 +125,6 @@ @Test - @Ignore("FIXME") - public void testImmediateDispatcher() { + @Disabled("FIXME") + void testImmediateDispatcher() { dispatcher = Dispatcher.immediate(); dispatcher.dispatch(1, integerSubscribers.iterator()); Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/EventBusTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/EventBusTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/EventBusTest.java (revision 36064) @@ -17,9 +17,10 @@ package org.openstreetmap.josm.eventbus; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.util.ArrayList; -import java.util.Arrays; +import java.util.Collections; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; @@ -29,11 +30,6 @@ import java.util.concurrent.atomic.AtomicInteger; -import org.junit.Before; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.DeadEvent; -import org.openstreetmap.josm.eventbus.EventBus; -import org.openstreetmap.josm.eventbus.Subscribe; -import org.openstreetmap.josm.eventbus.SubscriberExceptionContext; -import org.openstreetmap.josm.eventbus.SubscriberExceptionHandler; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** @@ -42,5 +38,5 @@ * @author Cliff Biffle */ -public class EventBusTest { +class EventBusTest { private static final String EVENT = "Hello"; private static final String BUS_IDENTIFIER = "test-bus"; @@ -48,11 +44,11 @@ private EventBus bus; - @Before - public void setUp() throws Exception { + @BeforeEach + void setUp() { bus = new EventBus(BUS_IDENTIFIER); } @Test - public void testBasicCatcherDistribution() { + void testBasicCatcherDistribution() { StringCatcher catcher = new StringCatcher(); bus.register(catcher); @@ -60,6 +56,6 @@ List events = catcher.getEvents(); - assertEquals("Only one event should be delivered.", 1, events.size()); - assertEquals("Correct string should be delivered.", EVENT, events.get(0)); + assertEquals(1, events.size(), "Only one event should be delivered."); + assertEquals(EVENT, events.get(0), "Correct string should be delivered."); } @@ -71,5 +67,5 @@ */ @Test - public void testPolymorphicDistribution() { + void testPolymorphicDistribution() { // Three catchers for related types String, Object, and Comparable. // String isa Object @@ -101,5 +97,5 @@ // Two additional event types: Object and Comparable (played by Integer) Object objEvent = new Object(); - Object compEvent = new Integer(6); + Object compEvent = 6; bus.post(EVENT); @@ -109,23 +105,21 @@ // Check the StringCatcher... List stringEvents = stringCatcher.getEvents(); - assertEquals("Only one String should be delivered.", 1, stringEvents.size()); - assertEquals("Correct string should be delivered.", EVENT, stringEvents.get(0)); + assertEquals(1, stringEvents.size(), "Only one String should be delivered."); + assertEquals(EVENT, stringEvents.get(0), "Correct string should be delivered."); // Check the Catcher... - assertEquals("Three Objects should be delivered.", 3, objectEvents.size()); - assertEquals("String fixture must be first object delivered.", EVENT, objectEvents.get(0)); - assertEquals("Object fixture must be second object delivered.", objEvent, objectEvents.get(1)); - assertEquals( - "Comparable fixture must be thirdobject delivered.", compEvent, objectEvents.get(2)); + assertEquals(3, objectEvents.size(), "Three Objects should be delivered."); + assertEquals(EVENT, objectEvents.get(0), "String fixture must be first object delivered."); + assertEquals(objEvent, objectEvents.get(1), "Object fixture must be second object delivered."); + assertEquals(compEvent, objectEvents.get(2), "Comparable fixture must be thirdobject delivered."); // Check the Catcher>... - assertEquals("Two Comparables should be delivered.", 2, compEvents.size()); - assertEquals("String fixture must be first comparable delivered.", EVENT, compEvents.get(0)); - assertEquals( - "Comparable fixture must be second comparable delivered.", compEvent, compEvents.get(1)); - } - - @Test - public void testSubscriberThrowsException() throws Exception { + assertEquals(2, compEvents.size(), "Two Comparables should be delivered."); + assertEquals(EVENT, compEvents.get(0), "String fixture must be first comparable delivered."); + assertEquals(compEvent, compEvents.get(1), "Comparable fixture must be second comparable delivered."); + } + + @Test + void testSubscriberThrowsException() throws Exception { final RecordingSubscriberExceptionHandler handler = new RecordingSubscriberExceptionHandler(); final EventBus eventBus = new EventBus(handler); @@ -142,24 +136,18 @@ eventBus.post(EVENT); - assertEquals("Cause should be available.", exception, handler.exception); - assertEquals("EventBus should be available.", eventBus, handler.context.getEventBus()); - assertEquals("Event should be available.", EVENT, handler.context.getEvent()); - assertEquals("Subscriber should be available.", subscriber, handler.context.getSubscriber()); - assertEquals( - "Method should be available.", - subscriber.getClass().getMethod("throwExceptionOn", String.class), - handler.context.getSubscriberMethod()); - } - - @Test - public void testSubscriberThrowsExceptionHandlerThrowsException() throws Exception { + assertEquals(exception, handler.exception, "Cause should be available."); + assertEquals(eventBus, handler.context.getEventBus(), "EventBus should be available."); + assertEquals(EVENT, handler.context.getEvent(), "Event should be available."); + assertEquals(subscriber, handler.context.getSubscriber(), "Subscriber should be available."); + assertEquals(subscriber.getClass().getMethod("throwExceptionOn", String.class), handler.context.getSubscriberMethod(), "Method should be available."); + } + + @Test + void testSubscriberThrowsExceptionHandlerThrowsException() throws Exception { final EventBus eventBus = new EventBus( - new SubscriberExceptionHandler() { - @Override - public void handleException(Throwable exception, SubscriberExceptionContext context) { - throw new RuntimeException("testSubscriberThrowsExceptionHandlerThrowsException_1. This is a normal exception"); - } - }); + (exception, context) -> { + throw new RuntimeException("testSubscriberThrowsExceptionHandlerThrowsException_1. This is a normal exception"); + }); final Object subscriber = new Object() { @@ -170,13 +158,9 @@ }; eventBus.register(subscriber); - try { - eventBus.post(EVENT); - } catch (RuntimeException e) { - fail("Exception should not be thrown."); - } - } - - @Test - public void testDeadEventForwarding() { + assertDoesNotThrow(() -> eventBus.post(EVENT)); + } + + @Test + void testDeadEventForwarding() { GhostCatcher catcher = new GhostCatcher(); bus.register(catcher); @@ -186,10 +170,10 @@ List events = catcher.getEvents(); - assertEquals("One dead event should be delivered.", 1, events.size()); - assertEquals("The dead event should wrap the original event.", EVENT, events.get(0).getEvent()); - } - - @Test - public void testDeadEventPosting() { + assertEquals(1, events.size(), "One dead event should be delivered."); + assertEquals(EVENT, events.get(0).getEvent(), "The dead event should wrap the original event."); + } + + @Test + void testDeadEventPosting() { GhostCatcher catcher = new GhostCatcher(); bus.register(catcher); @@ -198,23 +182,18 @@ List events = catcher.getEvents(); - assertEquals("The explicit DeadEvent should be delivered.", 1, events.size()); - assertEquals("The dead event must not be re-wrapped.", EVENT, events.get(0).getEvent()); - } - - @Test - public void testMissingSubscribe() { + assertEquals(1, events.size(), "The explicit DeadEvent should be delivered."); + assertEquals(EVENT, events.get(0).getEvent(), "The dead event must not be re-wrapped."); + } + + @Test + void testMissingSubscribe() { bus.register(new Object()); } @Test - public void testUnregister() { + void testUnregister() { StringCatcher catcher1 = new StringCatcher(); StringCatcher catcher2 = new StringCatcher(); - try { - bus.unregister(catcher1); - fail("Attempting to unregister an unregistered object succeeded"); - } catch (IllegalArgumentException expected) { - // OK. - } + assertThrows(IllegalArgumentException.class, () -> bus.unregister(catcher1), "Attempting to unregister an unregistered object succeeded"); bus.register(catcher1); @@ -227,29 +206,20 @@ expectedEvents.add(EVENT); - assertEquals("Two correct events should be delivered.", expectedEvents, catcher1.getEvents()); - - assertEquals( - "One correct event should be delivered.", Arrays.asList(EVENT), catcher2.getEvents()); + assertEquals(expectedEvents, catcher1.getEvents(), "Two correct events should be delivered."); + + assertEquals(Collections.singletonList(EVENT), catcher2.getEvents(), "One correct event should be delivered."); bus.unregister(catcher1); bus.post(EVENT); - assertEquals( - "Shouldn't catch any more events when unregistered.", expectedEvents, catcher1.getEvents()); - assertEquals("Two correct events should be delivered.", expectedEvents, catcher2.getEvents()); - - try { - bus.unregister(catcher1); - fail("Attempting to unregister an unregistered object succeeded"); - } catch (IllegalArgumentException expected) { - // OK. - } + assertEquals(expectedEvents, catcher1.getEvents(), "Shouldn't catch any more events when unregistered."); + assertEquals(expectedEvents, catcher2.getEvents(), "Two correct events should be delivered."); + + assertThrows(IllegalArgumentException.class, () -> bus.unregister(catcher1), "Attempting to unregister an unregistered object succeeded"); bus.unregister(catcher2); bus.post(EVENT); - assertEquals( - "Shouldn't catch any more events when unregistered.", expectedEvents, catcher1.getEvents()); - assertEquals( - "Shouldn't catch any more events when unregistered.", expectedEvents, catcher2.getEvents()); + assertEquals(expectedEvents, catcher1.getEvents(), "Shouldn't catch any more events when unregistered."); + assertEquals(expectedEvents, catcher2.getEvents(), "Shouldn't catch any more events when unregistered."); } @@ -258,5 +228,5 @@ @Test - public void testRegisterThreadSafety() throws Exception { + void testRegisterThreadSafety() throws Exception { List catchers = new CopyOnWriteArrayList<>(); List> futures = new ArrayList<>(); @@ -269,17 +239,14 @@ futures.get(i).get(); } - assertEquals("Unexpected number of catchers in the list", numberOfCatchers, catchers.size()); - bus.post(EVENT); - List expectedEvents = Arrays.asList(EVENT); + assertEquals(numberOfCatchers, catchers.size(), "Unexpected number of catchers in the list"); + bus.post(EVENT); + List expectedEvents = Collections.singletonList(EVENT); for (StringCatcher catcher : catchers) { - assertEquals( - "One of the registered catchers did not receive an event.", - expectedEvents, - catcher.getEvents()); - } - } - - @Test - public void testToString() throws Exception { + assertEquals(expectedEvents, catcher.getEvents(), "One of the registered catchers did not receive an event."); + } + } + + @Test + void testToString() { EventBus eventBus = new EventBus("a b ; - \" < > / \\ €"); assertEquals("EventBus [a b ; - \" < > / \\ €]", eventBus.toString()); @@ -293,5 +260,5 @@ */ @Test - public void testRegistrationWithBridgeMethod() { + void testRegistrationWithBridgeMethod() { final AtomicInteger calls = new AtomicInteger(); bus.register( @@ -347,5 +314,5 @@ */ public static class GhostCatcher { - private List events = new ArrayList<>(); + private final List events = new ArrayList<>(); @Subscribe Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/ReentrantEventsTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/ReentrantEventsTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/ReentrantEventsTest.java (revision 36064) @@ -17,6 +17,5 @@ package org.openstreetmap.josm.eventbus; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.ArrayList; @@ -24,7 +23,6 @@ import java.util.List; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.EventBus; -import org.openstreetmap.josm.eventbus.Subscribe; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; /** @@ -33,5 +31,5 @@ * @author Jesse Wilson */ -public class ReentrantEventsTest { +class ReentrantEventsTest { static final String FIRST = "one"; @@ -41,5 +39,5 @@ @Test - public void testNoReentrantEvents() { + void testNoReentrantEvents() { ReentrantEventsHater hater = new ReentrantEventsHater(); bus.register(hater); @@ -47,8 +45,5 @@ bus.post(FIRST); - assertEquals( - "ReentrantEventHater expected 2 events", - Arrays.asList(FIRST, SECOND), - hater.eventsReceived); + assertEquals(Arrays.asList(FIRST, SECOND), hater.eventsReceived, "ReentrantEventHater expected 2 events"); } @@ -70,5 +65,5 @@ @Subscribe public void listenForDoubles(Double event) { - assertTrue("I received an event when I wasn't ready!", ready); + Assertions.assertTrue(ready, "I received an event when I wasn't ready!"); eventsReceived.add(event); } @@ -76,5 +71,5 @@ @Test - public void testEventOrderingIsPredictable() { + void testEventOrderingIsPredictable() { EventProcessor processor = new EventProcessor(); bus.register(processor); @@ -85,8 +80,5 @@ bus.post(FIRST); - assertEquals( - "EventRecorder expected events in order", - Arrays.asList(FIRST, SECOND), - recorder.eventsReceived); + assertEquals(Arrays.asList(FIRST, SECOND), recorder.eventsReceived, "EventRecorder expected events in order"); } Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/StringCatcher.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/StringCatcher.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/StringCatcher.java (revision 36064) @@ -17,10 +17,8 @@ package org.openstreetmap.josm.eventbus; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.fail; import java.util.ArrayList; import java.util.List; - -import org.openstreetmap.josm.eventbus.Subscribe; /** @@ -33,5 +31,5 @@ */ public class StringCatcher { - private List events = new ArrayList<>(); + private final List events = new ArrayList<>(); @Subscribe Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberRegistryTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberRegistryTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberRegistryTest.java (revision 36064) @@ -17,8 +17,8 @@ package org.openstreetmap.josm.eventbus; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; @@ -26,10 +26,8 @@ import java.util.Iterator; -import org.junit.Ignore; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.EventBus; -import org.openstreetmap.josm.eventbus.Subscribe; -import org.openstreetmap.josm.eventbus.Subscriber; -import org.openstreetmap.josm.eventbus.SubscriberRegistry; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + /** @@ -43,5 +41,5 @@ @Test - public void testRegister() { + void testRegister() { assertEquals(0, registry.getSubscribersForTesting(String.class).size()); @@ -58,5 +56,5 @@ @Test - public void testUnregister() { + void testUnregister() { StringSubscriber s1 = new StringSubscriber(); StringSubscriber s2 = new StringSubscriber(); @@ -73,31 +71,19 @@ @Test - public void testUnregister_notRegistered() { - try { - registry.unregister(new StringSubscriber()); - fail(); - } catch (IllegalArgumentException expected) { - } + void testUnregisterNotRegistered() { + StringSubscriber temp = new StringSubscriber(); + assertThrows(IllegalArgumentException.class, () -> registry.unregister(temp)); StringSubscriber s1 = new StringSubscriber(); registry.register(s1); - try { - registry.unregister(new StringSubscriber()); - fail(); - } catch (IllegalArgumentException expected) { - // a StringSubscriber was registered, but not the same one we tried to unregister - } + // a StringSubscriber was registered, but not the same one we tried to unregister + assertThrows(IllegalArgumentException.class, () -> registry.unregister(temp)); registry.unregister(s1); - - try { - registry.unregister(s1); - fail(); - } catch (IllegalArgumentException expected) { - } - } - - @Test - public void testGetSubscribers() { + assertThrows(IllegalArgumentException.class, () -> registry.unregister(s1)); + } + + @Test + void testGetSubscribers() { assertEquals(0, size(registry.getSubscribers(""))); @@ -120,6 +106,6 @@ @Test - @Ignore("FIXME") - public void testGetSubscribers_returnsImmutableSnapshot() { + @Disabled("FIXME") + void testGetSubscribersReturnsImmutableSnapshot() { StringSubscriber s1 = new StringSubscriber(); StringSubscriber s2 = new StringSubscriber(); @@ -186,13 +172,11 @@ @Test - public void testFlattenHierarchy() { - assertEquals( - new HashSet<>(Arrays.asList( - Object.class, - HierarchyFixtureInterface.class, - HierarchyFixtureSubinterface.class, - HierarchyFixtureParent.class, - HierarchyFixture.class)), - SubscriberRegistry.flattenHierarchy(HierarchyFixture.class)); + void testFlattenHierarchy() { + assertEquals(new HashSet<>(Arrays.asList( + Object.class, + HierarchyFixtureInterface.class, + HierarchyFixtureSubinterface.class, + HierarchyFixtureParent.class, + HierarchyFixture.class)), SubscriberRegistry.flattenHierarchy(HierarchyFixture.class)); } Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberTest.java (revision 36064) @@ -18,15 +18,16 @@ //import com.google.common.testing.EqualsTester; + +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import org.junit.Ignore; -import org.junit.Test; -import org.openstreetmap.josm.eventbus.AllowConcurrentEvents; -import org.openstreetmap.josm.eventbus.EventBus; -import org.openstreetmap.josm.eventbus.Subscribe; -import org.openstreetmap.josm.eventbus.Subscriber; - -import junit.framework.TestCase; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; /** @@ -36,5 +37,5 @@ * @author Colin Decker */ -public class SubscriberTest extends TestCase { +class SubscriberTest { private static final Object FIXTURE_ARGUMENT = new Object(); @@ -44,6 +45,6 @@ private Object methodArgument; - @Override - protected void setUp() throws Exception { + @BeforeEach + protected void setUp() { bus = new EventBus(); methodCalled = false; @@ -52,5 +53,5 @@ @Test - public void testCreate() { + void testCreate() { Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod")); assertTrue(s1 instanceof Subscriber.SynchronizedSubscriber); @@ -58,9 +59,9 @@ // a thread-safe method should not create a synchronized subscriber Subscriber s2 = Subscriber.create(bus, this, getTestSubscriberMethod("threadSafeMethod")); - assertFalse(s2 instanceof Subscriber.SynchronizedSubscriber); + Assertions.assertFalse(s2 instanceof Subscriber.SynchronizedSubscriber); } @Test - public void testInvokeSubscriberMethod_basicMethodCall() throws Throwable { + void testInvokeSubscriberMethodBasicMethodCall() throws Throwable { Method method = getTestSubscriberMethod("recordingMethod"); Subscriber subscriber = Subscriber.create(bus, this, method); @@ -68,38 +69,30 @@ subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT); - assertTrue("Subscriber must call provided method", methodCalled); - assertTrue( - "Subscriber argument must be exactly the provided object.", - methodArgument == FIXTURE_ARGUMENT); + assertTrue(methodCalled, "Subscriber must call provided method"); + assertSame(methodArgument, FIXTURE_ARGUMENT, "Subscriber argument must be exactly the provided object."); } @Test - public void testInvokeSubscriberMethod_exceptionWrapping() throws Throwable { + void testInvokeSubscriberMethodExceptionWrapping() { Method method = getTestSubscriberMethod("exceptionThrowingMethod"); Subscriber subscriber = Subscriber.create(bus, this, method); - try { - subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT); - fail("Subscribers whose methods throw must throw InvocationTargetException"); - } catch (InvocationTargetException expected) { - assertTrue(expected.getCause() instanceof IntentionalException); - } + InvocationTargetException ite = assertThrows(InvocationTargetException.class, () -> subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT), + "Subscribers whose methods throw must throw InvocationTargetException"); + assertTrue(ite.getCause() instanceof IntentionalException); } @Test - public void testInvokeSubscriberMethod_errorPassthrough() throws Throwable { + void testInvokeSubscriberMethodErrorPassthrough() { Method method = getTestSubscriberMethod("errorThrowingMethod"); Subscriber subscriber = Subscriber.create(bus, this, method); - try { - subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT); - fail("Subscribers whose methods throw Errors must rethrow them"); - } catch (JudgmentError expected) { - } + assertThrows(JudgmentError.class, () -> subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT), + "Subscribers whose methods throw Errors must rethrow them"); } @Test - @Ignore("FIXME") - public void testEquals() throws Exception { + @Disabled("FIXME") + void testEquals() { /*Method charAt = String.class.getMethod("charAt", int.class); Method concat = String.class.getMethod("concat", String.class); @@ -128,5 +121,5 @@ @Subscribe public void recordingMethod(Object arg) { - assertFalse(methodCalled); + Assertions.assertFalse(methodCalled); methodCalled = true; methodArgument = arg; @@ -139,5 +132,5 @@ /** Local exception subclass to check variety of exception thrown. */ - class IntentionalException extends Exception { + static class IntentionalException extends Exception { private static final long serialVersionUID = -2500191180248181379L; Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/AnnotatedSubscriberFinderTests.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/AnnotatedSubscriberFinderTests.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/AnnotatedSubscriberFinderTests.java (revision 36064) @@ -17,12 +17,13 @@ package org.openstreetmap.josm.eventbus.outside; -import static org.junit.Assert.assertTrue; + +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.List; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.openstreetmap.josm.eventbus.EventBus; import org.openstreetmap.josm.eventbus.Subscribe; @@ -48,6 +49,6 @@ } - @Before - public void setUp() throws Exception { + @BeforeEach + public void setUp() { subscriber = createSubscriber(); EventBus bus = new EventBus(); @@ -56,6 +57,6 @@ } - @After - public void tearDown() throws Exception { + @AfterEach + public void tearDown() { subscriber = null; } @@ -65,5 +66,5 @@ * We break the tests up based on whether they are annotated or abstract in the superclass. */ - public static class BaseSubscriberFinderTest + static class BaseSubscriberFinderTest extends AbstractEventBusTestParent { static class Subscriber { @@ -82,10 +83,10 @@ @Test - public void testNonSubscriber() { + void testNonSubscriber() { assertTrue(getSubscriber().nonSubscriberEvents.isEmpty()); } @Test - public void testSubscriber() { + void testSubscriber() { assertTrue(getSubscriber().subscriberEvents.contains(EVENT)); } @@ -97,5 +98,5 @@ } - public static class AnnotatedAndAbstractInSuperclassTest + static class AnnotatedAndAbstractInSuperclassTest extends AbstractEventBusTestParent { abstract static class SuperClass { @@ -124,10 +125,10 @@ @Test - public void testOverriddenAndAnnotatedInSubclass() { + void testOverriddenAndAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT)); } @Test - public void testOverriddenNotAnnotatedInSubclass() { + void testOverriddenNotAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenInSubclassEvents.contains(EVENT)); } @@ -139,5 +140,5 @@ } - public static class AnnotatedNotAbstractInSuperclassTest + static class AnnotatedNotAbstractInSuperclassTest extends AbstractEventBusTestParent { static class SuperClass { @@ -206,15 +207,15 @@ @Test - public void testNotOverriddenInSubclass() { + void testNotOverriddenInSubclass() { assertTrue(getSubscriber().notOverriddenInSubclassEvents.contains(EVENT)); } @Test - public void testOverriddenNotAnnotatedInSubclass() { + void testOverriddenNotAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenNotAnnotatedInSubclassEvents.contains(EVENT)); } @Test - public void testDifferentlyOverriddenNotAnnotatedInSubclass() { + void testDifferentlyOverriddenNotAnnotatedInSubclass() { assertTrue(getSubscriber().differentlyOverriddenNotAnnotatedInSubclassGoodEvents .contains(EVENT)); @@ -223,10 +224,10 @@ @Test - public void testOverriddenAndAnnotatedInSubclass() { + void testOverriddenAndAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT)); } @Test - public void testDifferentlyOverriddenAndAnnotatedInSubclass() { + void testDifferentlyOverriddenAndAnnotatedInSubclass() { assertTrue(getSubscriber().differentlyOverriddenAnnotatedInSubclassGoodEvents .contains(EVENT)); @@ -240,5 +241,5 @@ } - public static class AbstractNotAnnotatedInSuperclassTest + static class AbstractNotAnnotatedInSuperclassTest extends AbstractEventBusTestParent { abstract static class SuperClass { @@ -265,10 +266,10 @@ @Test - public void testOverriddenAndAnnotatedInSubclass() { + void testOverriddenAndAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT)); } @Test - public void testOverriddenInSubclassNowhereAnnotated() { + void testOverriddenInSubclassNowhereAnnotated() { assertTrue(getSubscriber().overriddenInSubclassNowhereAnnotatedEvents.isEmpty()); } @@ -280,5 +281,5 @@ } - public static class NeitherAbstractNorAnnotatedInSuperclassTest + static class NeitherAbstractNorAnnotatedInSuperclassTest extends AbstractEventBusTestParent { static class SuperClass { @@ -314,15 +315,15 @@ @Test - public void testNeitherOverriddenNorAnnotated() { + void testNeitherOverriddenNorAnnotated() { assertTrue(getSubscriber().neitherOverriddenNorAnnotatedEvents.isEmpty()); } @Test - public void testOverriddenInSubclassNowhereAnnotated() { + void testOverriddenInSubclassNowhereAnnotated() { assertTrue(getSubscriber().overriddenInSubclassNowhereAnnotatedEvents.isEmpty()); } @Test - public void testOverriddenAndAnnotatedInSubclass() { + void testOverriddenAndAnnotatedInSubclass() { assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT)); } @@ -334,5 +335,5 @@ } - public static class DeepInterfaceTest + static class DeepInterfaceTest extends AbstractEventBusTestParent { interface Interface1 { @@ -427,40 +428,40 @@ @Test - public void testAnnotatedIn1() { + void testAnnotatedIn1() { assertTrue(getSubscriber().annotatedIn1Events.contains(EVENT)); } @Test - public void testAnnotatedIn2() { + void testAnnotatedIn2() { assertTrue(getSubscriber().annotatedIn2Events.contains(EVENT)); } @Test - public void testAnnotatedIn1And2() { + void testAnnotatedIn1And2() { assertTrue(getSubscriber().annotatedIn1And2Events.contains(EVENT)); } @Test - public void testAnnotatedIn1And2AndClass() { + void testAnnotatedIn1And2AndClass() { assertTrue(getSubscriber().annotatedIn1And2AndClassEvents.contains(EVENT)); } @Test - public void testDeclaredIn1AnnotatedIn2() { + void testDeclaredIn1AnnotatedIn2() { assertTrue(getSubscriber().declaredIn1AnnotatedIn2Events.contains(EVENT)); } @Test - public void testDeclaredIn1AnnotatedInClass() { + void testDeclaredIn1AnnotatedInClass() { assertTrue(getSubscriber().declaredIn1AnnotatedInClassEvents.contains(EVENT)); } @Test - public void testDeclaredIn2AnnotatedInClass() { + void testDeclaredIn2AnnotatedInClass() { assertTrue(getSubscriber().declaredIn2AnnotatedInClassEvents.contains(EVENT)); } @Test - public void testNowhereAnnotated() { + void testNowhereAnnotated() { assertTrue(getSubscriber().nowhereAnnotatedEvents.isEmpty()); } Index: applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/OutsideEventBusTest.java =================================================================== --- applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/OutsideEventBusTest.java (revision 35952) +++ applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/OutsideEventBusTest.java (revision 36064) @@ -17,10 +17,10 @@ package org.openstreetmap.josm.eventbus.outside; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.openstreetmap.josm.eventbus.EventBus; import org.openstreetmap.josm.eventbus.Subscribe; @@ -31,5 +31,5 @@ * @author Louis Wasserman */ -public class OutsideEventBusTest { +class OutsideEventBusTest { /* @@ -39,5 +39,5 @@ */ @Test - public void testAnonymous() { + void testAnonymous() { final AtomicReference holder = new AtomicReference<>(); final AtomicInteger deliveries = new AtomicInteger(); @@ -55,6 +55,6 @@ bus.post(EVENT); - assertEquals("Only one event should be delivered.", 1, deliveries.get()); - assertEquals("Correct string should be delivered.", EVENT, holder.get()); + assertEquals(1, deliveries.get(), "Only one event should be delivered."); + assertEquals(EVENT, holder.get(), "Correct string should be delivered."); } }