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<String> 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<Runnable> 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<String> 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<String> 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<Object>...
-    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<Comparable<?>>...
-    assertEquals("Two Comparable<?>s 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 Comparable<?>s 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<DeadEvent> 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<DeadEvent> 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<StringCatcher> catchers = new CopyOnWriteArrayList<>();
     List<Future<?>> 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<String> expectedEvents = Arrays.asList(EVENT);
+    assertEquals(numberOfCatchers, catchers.size(), "Unexpected number of catchers in the list");
+    bus.post(EVENT);
+    List<String> 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<DeadEvent> events = new ArrayList<>();
+    private final List<DeadEvent> 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<String> events = new ArrayList<>();
+  private final List<String> 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<BaseSubscriberFinderTest.Subscriber> {
     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<AnnotatedAndAbstractInSuperclassTest.SubClass> {
     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<AnnotatedNotAbstractInSuperclassTest.SubClass> {
     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<AbstractNotAnnotatedInSuperclassTest.SubClass> {
     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<NeitherAbstractNorAnnotatedInSuperclassTest.SubClass> {
     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<DeepInterfaceTest.SubscriberClass> {
     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<String> 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.");
   }
 }
