Changeset 36064 for applications/editors/josm/plugins – JOSM

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/StreetsideAbstractImageTest.java

-              r34432
+              r36064
 package org.openstreetmap.josm.plugins.streetside;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
+public class StreetsideAbstractImageTest {
+  /*@Rule
+  public JOSMTestRules rules = new StreetsideTestRules().platform();*/
+class StreetsideAbstractImageTest {
   @Test
   public void testIsModified() {
+  void testIsModified() {
     StreetsideImage img = new StreetsideImage("key___________________", new LatLon(0, 0), 0);
     assertFalse(img.isModified());

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/StreetsideDataTest.java

-              r34434
+              r36064
 package org.openstreetmap.josm.plugins.streetside;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import java.util.Arrays;
 import java.util.concurrent.ConcurrentSkipListSet;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIf;
 import org.openstreetmap.josm.data.coor.LatLon;
 …
  * @see StreetsideData
  */
+public class StreetsideDataTest {
+@DisabledIf(value = "org.openstreetmap.josm.plugins.streetside.utils.TestUtil#cannotLoadImages", disabledReason = "At JOSM maintainer request (flaky?)")
+class StreetsideDataTest {
   /*@Rule
 …
    * objects and a {@link StreetsideSequence} object.
    */
   @Before
+  @BeforeEach
   public void setUp() {
     img1 = new StreetsideImage("id1__________________", new LatLon(0.1, 0.1), 90);
 …
    * another one in the database, the one that is being added should be ignored.
    */
-  @Ignore
   @Test
   public void addTest() {
+  void testAdd() {
     data = new StreetsideData();
     assertEquals(0, data.getImages().size());
 …
    * Test that the size is properly calculated.
    */
-  @Ignore
   @Test
   public void sizeTest() {
+  void testSize() {
     assertEquals(4, data.getImages().size());
     data.add(new StreetsideImage("id5__________________", new LatLon(0.1, 0.1), 90));
 …
    * and {@link StreetsideData#getHighlightedImage()} methods.
    */
-  @Ignore
   @Test
   public void highlighTest() {
+  void testHighlight() {
     data.setHighlightedImage(img1);
     assertEquals(img1, data.getHighlightedImage());
     data.setHighlightedImage(null);
     assertEquals(null, data.getHighlightedImage());
+    assertNull(data.getHighlightedImage());
+  }
 …
    * Tests the selection of images.
    */
-  @Ignore
   @Test
   public void selectTest() {
+  void testSelect() {
     data.setSelectedImage(img1);
     assertEquals(img1, data.getSelectedImage());
 …
     data.setSelectedImage(null);
     assertEquals(null, data.getSelectedImage());
+    assertNull(data.getSelectedImage());
+  }
 …
    * {@link StreetsideData#selectPrevious()} methods.
    */
-  @Ignore
   @Test
   public void nextAndPreviousTest() {
+  void testNextAndPrevious() {
     data.setSelectedImage(img1);
 …
+  }
+  @Ignore
+  @Test(expected=IllegalStateException.class)
+  public void nextOfNullImgTest() {
+  @Test
+  void testNextOfNullImg() {
     data.setSelectedImage(null);
     data.selectNext();
+    assertThrows(IllegalStateException.class, data::selectNext);
+  }
+  @Ignore
+  @Test(expected=IllegalStateException.class)
+  public void previousOfNullImgTest() {
+  @Test
+  void testPreviousOfNullImg() {
     data.setSelectedImage(null);
     data.selectPrevious();
+    assertThrows(IllegalStateException.class, data::selectPrevious);
+  }
 …
    * multiselected List should reset.
    */
-  @Ignore
   @Test
   public void multiSelectTest() {
+  void testMultiSelect() {
     assertEquals(0, data.getMultiSelectedImages().size());
     data.setSelectedImage(img1);

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/StreetsideLayerTest.java

-              r34434
+              r36064
 package org.openstreetmap.josm.plugins.streetside;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIf;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.imagery.ImageryInfo;
 …
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.plugins.streetside.cubemap.CubemapUtils;
-import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Main;
+import org.openstreetmap.josm.testutils.annotations.Projection;
+public class StreetsideLayerTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules().main().preferences().projection();
+@BasicPreferences
+@Main
+@Projection
+@DisabledIf(value = "org.openstreetmap.josm.plugins.streetside.utils.TestUtil#cannotLoadImages", disabledReason = "At JOSM maintainer request (flaky?)")
+class StreetsideLayerTest {
   private static Layer getDummyLayer() {
     return ImageryLayer.create(new ImageryInfo("dummy", "https://example.org"));
+  }
-  @Ignore
   @Test
   public void testGetIcon() {
+  void testGetIcon() {
     assertNotNull(StreetsideLayer.getInstance().getIcon());
+  }
-  @Ignore
   @Test
   public void testIsMergable() {
+  void testIsMergable() {
     assertFalse(StreetsideLayer.getInstance().isMergable(getDummyLayer()));
+  }
+  @Ignore
+  @Test(expected = UnsupportedOperationException.class)
+  public void testMergeFrom() {
+    StreetsideLayer.getInstance().mergeFrom(getDummyLayer());
+  @Test
+  void testMergeFrom() {
+    StreetsideLayer layer = StreetsideLayer.getInstance();
+    Layer dummyLayer = getDummyLayer();
+    assertThrows(UnsupportedOperationException.class, () -> layer.mergeFrom(dummyLayer));
+  }
-  @Ignore
   @Test
   public void testSetVisible() {
+  void testSetVisible() {
     StreetsideLayer.getInstance().getData().add(new StreetsideImage(CubemapUtils.TEST_IMAGE_ID, new LatLon(0.0, 0.0), 0.0));
     StreetsideLayer.getInstance().getData().add(new StreetsideImage(CubemapUtils.TEST_IMAGE_ID, new LatLon(0.0, 0.0), 0.0));
 …
     StreetsideLayer.getInstance().setVisible(false);
     for (StreetsideAbstractImage img : StreetsideLayer.getInstance().getData().getImages()) {
       assertEquals(false, img.isVisible());
+      assertFalse(img.isVisible());
+    }
 …
     StreetsideLayer.getInstance().setVisible(true);
     for (StreetsideAbstractImage img : StreetsideLayer.getInstance().getData().getImages()) {
       assertEquals(true, img.isVisible());
+      assertTrue(img.isVisible());
+    }
+  }
-  @Ignore
   @Test
   public void testGetInfoComponent() {
+  void testGetInfoComponent() {
     Object comp = StreetsideLayer.getInstance().getInfoComponent();
     assertTrue(comp instanceof String);
 …
+  }
-  @Ignore
   @Test
   public void testClearInstance() {
+  void testClearInstance() {
     StreetsideLayer.getInstance();
     assertTrue(StreetsideLayer.hasInstance());

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/StreetsideSequenceTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+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.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import java.util.Arrays;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 …
  * @see StreetsideSequence
  */
 public class StreetsideSequenceTest {
+class StreetsideSequenceTest {
   private final StreetsideImage img1 = new StreetsideImage("key1", new LatLon(0.1, 0.1), 90);
 …
    * {@link StreetsideSequence} object.
    */
   @Before
+  @BeforeEach
   public void setUp() {
     seq.add(Arrays.asList(img1, img2, img3, img4));
 …
    */
   @Test
   public void nextAndPreviousTest() {
+  void testNextAndPrevious() {
     assertEquals(img2, img1.next());
     assertEquals(img1, img2.previous());
 …
     // Test IllegalArgumentException when asking for the next image of an image
     // that is not in the sequence.
+    try {
+      seq.next(imgWithoutSeq);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+    assertThrows(IllegalArgumentException.class, () -> seq.next(imgWithoutSeq));
     // Test IllegalArgumentException when asking for the previous image of an
     // image that is not in the sequence.
+    try {
+      seq.previous(imgWithoutSeq);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+    assertThrows(IllegalArgumentException.class, () -> seq.previous(imgWithoutSeq));
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/cache/CachesTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.cache;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.streetside.utils.TestUtil;
 public class CachesTest {
+class CachesTest {
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(Caches.class);
+  }

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/cache/StreetsideCacheTest.java

-              r34386
+              r36064
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.cache;
-//License: GPL. For details, see LICENSE file.
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.plugins.streetside.cache.StreetsideCache.Type;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.plugins.streetside.cache.StreetsideCache.Type;
+import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+public class StreetsideCacheTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules().preferences();
+@BasicPreferences
+class StreetsideCacheTest {
   @Test
   public void test() {
+  void testCache() {
     StreetsideCache cache = new StreetsideCache("00000", Type.FULL_IMAGE);
     assertNotNull(cache.getUrl());

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/cubemap/CubemapUtilsTest.java

-              r34432
+              r36064
 package org.openstreetmap.josm.plugins.streetside.cubemap;
-import static org.junit.Assert.assertEquals;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+public class CubemapUtilsTest {
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+  @SuppressWarnings("static-method")
+class CubemapUtilsTest {
   @Test
   public final void testConvertDecimal2Quaternary() {
    final long decimal0 = 680730040l;
    final long decimal1 = 680931568l;
+  void testConvertDecimal2Quaternary() {
+   final long decimal0 = 680730040L;
+   final long decimal1 = 680931568L;
    String res = CubemapUtils.convertDecimal2Quaternary(decimal0);
    assertEquals("220210301312320", res);
 …
+  }
-  @SuppressWarnings("static-method")
   @Test
   public final void testConvertQuaternary2Decimal() {
+  void testConvertQuaternary2Decimal() {
     final String quadKey0 = "220210301312320";
     final String quadKey1 = "220211203003300";
 …
+  }
+  @SuppressWarnings("static-method")
+  @Ignore
+  @Disabled
   @Test
   public final void testGetFaceNumberForCount() {
+  void testGetFaceNumberForCount() {
     String faceNrFront = CubemapUtils.getFaceNumberForCount(0);
     String faceNrRight = CubemapUtils.getFaceNumberForCount(1);
 …
+  }
+  @SuppressWarnings("static-method")
+  @Ignore
+  @Disabled
   @Test
   public final void testGetCount4FaceNumber() {
+  void testGetCount4FaceNumber() {
     int count4Front = CubemapUtils.getCount4FaceNumber("01");
     int count4Right = CubemapUtils.getCount4FaceNumber("02");
 …
+  }
-  @SuppressWarnings("static-method")
   @Test
   public final void testConvertDoubleCountNrto16TileNr() {
+  void testConvertDoubleCountNrto16TileNr() {
     String x0y0 = CubemapUtils.convertDoubleCountNrto16TileNr("00");
     String x0y1 = CubemapUtils.convertDoubleCountNrto16TileNr("01");
 …
     assertEquals(x1y0, "02");
     assertEquals(x1y1, "03");
     assertEquals(x1y2,"12");
+    assertEquals(x1y2, "12");
     assertEquals(x1y3, "13");
     assertEquals(x2y0, "20");
 …
     assertEquals(x2y3, "31");
     assertEquals(x3y0, "22");
     assertEquals(x3y1,"23");
+    assertEquals(x3y1, "23");
     assertEquals(x3y2, "32");
     assertEquals(x3y3, "33");
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/cubemap/TileDownloadingTaskTest.java

-              r34428
+              r36064
 package org.openstreetmap.josm.plugins.streetside.cubemap;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.ArrayList;
 …
 import java.util.concurrent.Future;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+public class TileDownloadingTaskTest {
+@Disabled
+class TileDownloadingTaskTest {
-  @SuppressWarnings("static-method")
-  @Ignore
   @Test
   public final void testCall() {
+  final void testCall() throws InterruptedException {
     ExecutorService pool = Executors.newFixedThreadPool(1);
     List<Callable<List<String>>> tasks = new ArrayList<>(1);
       tasks.add(new TileDownloadingTask("2202112030033001233"));
+      try {
+        List<Future<List<String>>> results = pool.invokeAll(tasks);
+        assertEquals(results.get(0),"2202112030033001233");
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+        fail("Test threw an exception.");
+      }
+    List<Future<List<String>>> results = pool.invokeAll(tasks);
+    assertEquals(results.get(0), "2202112030033001233");
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/gui/ImageDisplayTest.java

-              r34432
+              r36064
 package org.openstreetmap.josm.plugins.streetside.gui;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.awt.GraphicsEnvironment;
 …
 import javax.swing.JFrame;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Tests {@link StreetsideImageDisplay}
  */
+public class ImageDisplayTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules().preferences();
+@BasicPreferences
+class ImageDisplayTest {
   private static final BufferedImage DUMMY_IMAGE = new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
   @Test
   public void testImagePersistence() {
+  void testImagePersistence() {
     StreetsideImageDisplay display = new StreetsideImageDisplay();
     display.setImage(DUMMY_IMAGE, null);
 …
   @Test
   public void testMouseWheelMoved() {
+  void testMouseWheelMoved() {
     if (GraphicsEnvironment.isHeadless()) {
       return;
 …
    */
   @Test
   public void testMouseClicked() {
+  void testMouseClicked() {
     if (GraphicsEnvironment.isHeadless()) {
       return;

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/gui/StreetsidePreferenceSettingTest.java

-              r34434
+              r36064
 package org.openstreetmap.josm.plugins.streetside.gui;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.openstreetmap.josm.plugins.streetside.utils.TestUtil.getPrivateFieldValue;
 …
 import javax.swing.SpinnerNumberModel;
 import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.preferences.BooleanProperty;
 import org.openstreetmap.josm.data.preferences.StringProperty;
 import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane;
 import org.openstreetmap.josm.plugins.streetside.io.download.StreetsideDownloader.DOWNLOAD_MODE;
+import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.Main;
+public class StreetsidePreferenceSettingTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules().main();
+@Main
+@Disabled
+class StreetsidePreferenceSettingTest {
   // TODO: repair broken unit test from Mapillary
-  @Ignore
   @Test
   public void testAddGui() {
+  void testAddGui() {
     if (GraphicsEnvironment.isHeadless()) {
       return;
 …
+  }
-  @Ignore
   @Test
   public void testIsExpert() {
     assertFalse(new StreetsidePreferenceSetting().isExpert());
+  void testIsExpert() {
+    Assertions.assertFalse(new StreetsidePreferenceSetting().isExpert());
+  }
   @SuppressWarnings("unchecked")
-  @Ignore
   @Test
   public void testOk() {
+  void testOk() {
     StreetsidePreferenceSetting settings = new StreetsidePreferenceSetting();

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/gui/boilerplate/SelectableLabelTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.gui.boilerplate;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+public class SelectableLabelTest {
+class SelectableLabelTest {
   @Test
   public void test() {
+  void testSelectableLabel() {
     SelectableLabel l1 = new SelectableLabel();
     assertFalse(l1.isEditable());
 …
     assertTrue(l2.getText().contains("some text"));
     assertFalse(l2.isEditable());
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/history/StreetsideRecordTest.java

-              r34433
+              r36064
 package org.openstreetmap.josm.plugins.streetside.history;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import java.util.Arrays;
 …
 import java.util.concurrent.ConcurrentSkipListSet;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
 …
 import org.openstreetmap.josm.plugins.streetside.history.commands.CommandUnjoin;
 import org.openstreetmap.josm.plugins.streetside.history.commands.StreetsideCommand;
 import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.Main;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  * @author nokutu
  */
+public class StreetsideRecordTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules().main().projection();
+@Main
+@Projection
+@Disabled
+class StreetsideRecordTest {
   private StreetsideRecord record;
 …
    * objects.
    */
   @Before
+  @BeforeEach
   public void setUp() {
     record = new StreetsideRecord();
 …
    * Test commands in general.
    */
+  @Ignore
+  @Test
+  public void commandTest() {
+  @Test
+  void testCommand() {
     StreetsideCommand cmd12 = new CommandMove(
             new ConcurrentSkipListSet<>(Arrays.asList(img1, img2)),
 …
    * Tests {@link CommandMove} class.
    */
+  @Ignore
+  @Test
+  public void commandMoveTest() {
+  @Test
+  void testCommandMove() {
     CommandMove cmd1 = new CommandMove(
             new ConcurrentSkipListSet<>(Arrays.asList(img1, img2)),
 …
    * Tests {@link CommandTurn} class.
    */
+  @Ignore
+  @Test
+  public void commandTurnTest() {
+  @Test
+  void testCommandTurn() {
     CommandTurn cmd1 = new CommandTurn(
             new ConcurrentSkipListSet<>(Arrays.asList(img1, img2)),
 …
    * Tests {@link CommandJoin} class.
    */
+  @Ignore
+  @Test
+  public void commandJoinClass() {
+  @Test
+  void testCommandJoinClass() {
     CommandJoin cmd1 = new CommandJoin(img1, img2);
     CommandJoin cmd2 = new CommandJoin(img2, img3);
 …
+  }
+  @Ignore
+  @Test(expected=NullPointerException.class)
+  public void commandJoinNull1() {
+    new CommandJoin(img1, null);
+  }
+  @Ignore
+  @Test(expected=NullPointerException.class)
+  public void commandJoinNull2() {
+    new CommandJoin(null, img1);
+  @Test
+  void testCommandJoinNull1() {
+    assertThrows(NullPointerException.class, () -> new CommandJoin(img1, null));
+  }
+  @Test
+  void commandJoinNull2() {
+    assertThrows(NullPointerException.class, () -> new CommandJoin(null, img1));
+  }
 …
    * Tests {@link CommandUnjoin} class.
    */
+  @Ignore
+  @Test
+  public void commandUnjoinClass() {
+  @Test
+  void testCommandUnjoinClass() {
     CommandJoin join1 = new CommandJoin(img1, img2);
     CommandJoin join2 = new CommandJoin(img2, img3);
 …
     assertEquals(1, img2.getSequence().getImages().size());
+    try {
+      record.addCommand(new CommandUnjoin(Arrays.asList(new StreetsideAbstractImage[]{img1, img2, img3})));
+      fail();
+    } catch (IllegalArgumentException e) {
+      // Expected output.
+    }
+    CommandUnjoin command = new CommandUnjoin(Arrays.asList(new StreetsideAbstractImage[]{img1, img2, img3}));
+    assertThrows(IllegalArgumentException.class, () -> record.addCommand(command));
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/io/download/SequenceDownloadRunnableTest.java

-              r34577
+              r36064
 package org.openstreetmap.josm.plugins.streetside.io.download;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.lang.reflect.Field;
 …
 import java.util.function.Function;
+import org.junit.AfterClass;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.Bounds;
-import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.plugins.streetside.StreetsideLayer;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
+import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.LayerManager;
+public class SequenceDownloadRunnableTest {
+  @Rule
+  public JOSMTestRules rules = new StreetsideTestRules();
+@Disabled
+@LayerManager
+class SequenceDownloadRunnableTest {
   private static final Function<Bounds, URL> SEARCH_SEQUENCES_URL_GEN = b -> {
 …
   private Field urlGenField;
-  @AfterClass
-  public static void tearDown() {
-    MainApplication.getLayerManager().resetState();
+  }
-  @Ignore
   @Test
   public void testRun1() throws IllegalArgumentException, IllegalAccessException {
+  void testRun1() throws IllegalArgumentException, IllegalAccessException {
     testNumberOfDecodedImages(4, SEARCH_SEQUENCES_URL_GEN, new Bounds(7.246497, 16.432955, 7.249027, 16.432976));
+  }
-  @Ignore
   @Test
   public void testRun2() throws IllegalArgumentException, IllegalAccessException {
+  void testRun2() throws IllegalArgumentException, IllegalAccessException {
     testNumberOfDecodedImages(0, SEARCH_SEQUENCES_URL_GEN, new Bounds(0, 0, 0, 0));
+  }
-  @Ignore
   @Test
   public void testRun3() throws IllegalArgumentException, IllegalAccessException {
+  void testRun3() throws IllegalArgumentException, IllegalAccessException {
     testNumberOfDecodedImages(0, b -> {
       try { return new URL("https://streetside/nonexistentURL"); } catch (MalformedURLException e) { return null; }
 …
+  }
-  @Ignore
   @Test
   public void testRun4() throws IllegalArgumentException, IllegalAccessException {
+  void testRun4() throws IllegalArgumentException, IllegalAccessException {
     StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.put(true);
     testNumberOfDecodedImages(4, SEARCH_SEQUENCES_URL_GEN, new Bounds(7.246497, 16.432955, 7.249027, 16.432976));
+  }
-  @Ignore
   @Test
   public void testRun5() throws IllegalArgumentException, IllegalAccessException {
+  void testRun5() throws IllegalArgumentException, IllegalAccessException {
     StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.put(true);
     testNumberOfDecodedImages(0, SEARCH_SEQUENCES_URL_GEN, new Bounds(0, 0, 0, 0));

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/ImageUtilTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.awt.image.BufferedImage;
 …
 import javax.swing.ImageIcon;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+public class ImageUtilTest {
+class ImageUtilTest {
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(ImageUtil.class);
+  }
   @Test
   public void testScaleImageIcon() {
+  void testScaleImageIcon() {
     ImageIcon largeLandscape = new ImageIcon(new BufferedImage(72, 60, BufferedImage.TYPE_4BYTE_ABGR));
     ImageIcon largePortrait = new ImageIcon(new BufferedImage(56, 88, BufferedImage.TYPE_4BYTE_ABGR));

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/PluginStateTest.java

-              r34583
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import javax.swing.JOptionPane;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.testutils.mockers.JOptionPaneSimpleMocker;
 …
  * @see PluginState
  */
 public class PluginStateTest {
+class PluginStateTest {
   /**
 …
    */
   @Test
   public void downloadTest() {
     assertEquals(false, PluginState.isDownloading());
+  void testDownload() {
+    assertFalse(PluginState.isDownloading());
     PluginState.startDownload();
     assertEquals(true, PluginState.isDownloading());
+    assertTrue(PluginState.isDownloading());
     PluginState.startDownload();
     assertEquals(true, PluginState.isDownloading());
+    assertTrue(PluginState.isDownloading());
     PluginState.finishDownload();
     assertEquals(true, PluginState.isDownloading());
+    assertTrue(PluginState.isDownloading());
     PluginState.finishDownload();
     assertEquals(false, PluginState.isDownloading());
+    assertFalse(PluginState.isDownloading());
+  }
 …
    */
   @Test
   public void uploadTest() {
+  void testUpload() {
     TestUtils.assumeWorkingJMockit();
     JOptionPaneSimpleMocker jopsMocker = new JOptionPaneSimpleMocker();
 …
             JOptionPane.OK_OPTION
         );
     assertEquals(false, PluginState.isUploading());
+    assertFalse(PluginState.isUploading());
     PluginState.addImagesToUpload(2);
     assertEquals(2, PluginState.getImagesToUpload());
     assertEquals(0, PluginState.getImagesUploaded());
     assertEquals(true, PluginState.isUploading());
+    assertTrue(PluginState.isUploading());
     PluginState.imageUploaded();
     assertEquals(1, PluginState.getImagesUploaded());
     assertEquals(true, PluginState.isUploading());
+    assertTrue(PluginState.isUploading());
     PluginState.imageUploaded();
     assertEquals(false, PluginState.isUploading());
+    assertFalse(PluginState.isUploading());
     assertEquals(2, PluginState.getImagesToUpload());
     assertEquals(2, PluginState.getImagesUploaded());

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/StreetsideColorSchemeTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import javax.swing.JComponent;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 public class StreetsideColorSchemeTest {
+class StreetsideColorSchemeTest {
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(StreetsideColorScheme.class);
+  }
   @Test
   public void testStyleAsDefaultPanel() {
     StreetsideColorScheme.styleAsDefaultPanel();
     StreetsideColorScheme.styleAsDefaultPanel((JComponent[]) null);
+  void testStyleAsDefaultPanel() {
+    assertDoesNotThrow(() -> StreetsideColorScheme.styleAsDefaultPanel());
+    assertDoesNotThrow(() -> StreetsideColorScheme.styleAsDefaultPanel((JComponent[]) null));
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/StreetsidePropertiesTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.plugins.streetside.utils.TestUtil.StreetsideTestRules;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.junit.jupiter.api.Test;
 public class StreetsidePropertiesTest {
-  @Rule
-  public JOSMTestRules rules = new StreetsideTestRules();
   @Test
   public void test() {
+  public void testUtilityClass() {
     TestUtil.testUtilityClass(StreetsideProperties.class);
+  }

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/StreetsideURLTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import java.lang.reflect.InvocationTargetException;
 …
 import java.net.URL;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 public class StreetsideURLTest {
+class StreetsideURLTest {
   // TODO: replace with Streetside URL @rrh
   private static final String CLIENT_ID_QUERY_PART = "client_id=T1Fzd20xZjdtR0s1VDk5OFNIOXpYdzoxNDYyOGRkYzUyYTFiMzgz";
 …
         @Test
     public void testParseNextFromHeaderValue() throws MalformedURLException {
+    void testParseNextFromHeaderValue() throws MalformedURLException {
       String headerVal =
         "<https://a.streetside.com/v3/sequences?page=1&per_page=200&client_id=TG1sUUxGQlBiYWx2V05NM0pQNUVMQTo2NTU3NTBiNTk1NzM1Y2U2>; rel=\"first\", " +
         "<https://a.streetside.com/v3/sequences?page=2&per_page=200&client_id=TG1sUUxGQlBiYWx2V05NM0pQNUVMQTo2NTU3NTBiNTk1NzM1Y2U2>; rel=\"prev\", " +
         "<https://a.streetside.com/v3/sequences?page=4&per_page=200&client_id=TG1sUUxGQlBiYWx2V05NM0pQNUVMQTo2NTU3NTBiNTk1NzM1Y2U2>; rel=\"next\"";
+      assertEquals(
+        new URL("https://a.streetside.com/v3/sequences?page=4&per_page=200&client_id=TG1sUUxGQlBiYWx2V05NM0pQNUVMQTo2NTU3NTBiNTk1NzM1Y2U2"),
+        StreetsideURL.APIv3.parseNextFromLinkHeaderValue(headerVal)
+      );
+      assertEquals(new URL("https://a.streetside.com/v3/sequences?page=4&per_page=200&client_id=TG1sUUxGQlBiYWx2V05NM0pQNUVMQTo2NTU3NTBiNTk1NzM1Y2U2"), StreetsideURL.APIv3.parseNextFromLinkHeaderValue(headerVal));
+    }
     @Test
     public void testParseNextFromHeaderValue2() throws MalformedURLException {
+    void testParseNextFromHeaderValue2() throws MalformedURLException {
       String headerVal =
         "<https://urlFirst>; rel=\"first\", " +
 …
     @Test
     public void testParseNextFromHeaderValueNull() {
       assertEquals(null, StreetsideURL.APIv3.parseNextFromLinkHeaderValue(null));
+    void testParseNextFromHeaderValueNull() {
+      assertNull(StreetsideURL.APIv3.parseNextFromLinkHeaderValue(null));
+    }
     @Test
     public void testParseNextFromHeaderValueMalformed() {
       assertEquals(null, StreetsideURL.APIv3.parseNextFromLinkHeaderValue("<###>; rel=\"next\", blub"));
+    void testParseNextFromHeaderValueMalformed() {
+      assertNull(StreetsideURL.APIv3.parseNextFromLinkHeaderValue("<###>; rel=\"next\", blub"));
+    }
 …
   }*/
   @Ignore
+  @Disabled
   @Test
+  public void testBrowseImageURL() throws MalformedURLException {
+    assertEquals(
+        new URL("https://www.streetside.com/map/im/1234567890123456789012"),
+        StreetsideURL.MainWebsite.browseImage("1234567890123456789012")
+    );
+  void testBrowseImageURL() throws MalformedURLException {
+    assertEquals(new URL("https://www.streetside.com/map/im/1234567890123456789012"), StreetsideURL.MainWebsite.browseImage("1234567890123456789012"));
+  }
   @Test(expected = IllegalArgumentException.class)
   public void testIllegalBrowseImageURL() {
     StreetsideURL.MainWebsite.browseImage(null);
+  @Test
+  void testIllegalBrowseImageURL() {
+    assertThrows(IllegalArgumentException.class, () -> StreetsideURL.MainWebsite.browseImage(null));
+  }
   @Ignore
+  @Disabled
   @Test
   public void testConnectURL() {
+  void testConnectURL() {
     /*assertUrlEquals(
         StreetsideURL.MainWebsite.connect("http://redirect-host/ä"),
 …
+  }
   @Ignore
+  @Disabled
   @Test
   public void testUploadSecretsURL() throws MalformedURLException {
+  void testUploadSecretsURL() throws MalformedURLException {
     /*assertEquals(
         new URL("https://a.streetside.com/v2/me/uploads/secrets?"+CLIENT_ID_QUERY_PART),
 …
+  }
   @Ignore
+  @Disabled
   @Test
   public void testUserURL() throws MalformedURLException {
+  void testUserURL() throws MalformedURLException {
     /*assertEquals(
         new URL("https://a.streetside.com/v3/me?"+CLIENT_ID_QUERY_PART),
 …
   @Test
   public void testString2MalformedURL()
+  void testString2MalformedURL()
       throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
     Method method = StreetsideURL.class.getDeclaredMethod("string2URL", String[].class);
     method.setAccessible(true);
     assertNull(method.invoke(null, new Object[]{new String[]{"malformed URL"}})); // this simply invokes string2URL("malformed URL")
     assertNull(method.invoke(null, new Object[]{null})); // invokes string2URL(null)
+    Assertions.assertNull(method.invoke(null, new Object[]{new String[]{"malformed URL"}})); // this simply invokes string2URL("malformed URL")
+    Assertions.assertNull(method.invoke(null, new Object[]{null})); // invokes string2URL(null)
+  }
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(StreetsideURL.class);
     TestUtil.testUtilityClass(StreetsideURL.APIv3.class);
 …
         parameterIsPresent |= actualParams[acIndex].equals(expectedParams[exIndex]);
+      }
+      assertTrue(
+          expectedParams[exIndex] + " was expected in the query string of " + actualUrl.toString() + " but wasn't there.",
+          parameterIsPresent
+      );
+      Assertions.assertTrue(parameterIsPresent, expectedParams[exIndex] + " was expected in the query string of " + actualUrl.toString() + " but wasn't there.");
+    }
+  }

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/StreetsideUtilsTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import org.apache.commons.imaging.common.RationalNumber;
 import org.apache.commons.imaging.formats.tiff.constants.GpsTagConstants;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 /**
 …
+ *
  */
 public class StreetsideUtilsTest {
+class StreetsideUtilsTest {
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(StreetsideUtils.class);
+  }
 …
    */
   @Test
   public void degMinSecToDoubleTest() {
+  void testDegMinSecToDouble() {
     RationalNumber[] num = new RationalNumber[3];
     num[0] = new RationalNumber(1, 1);

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/TestUtil.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils;
 import static org.junit.Assert.assertEquals;
 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.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 import java.awt.GraphicsEnvironment;
 …
 import org.junit.runners.model.InitializationError;
+import org.openstreetmap.josm.plugins.streetside.StreetsidePlugin;
+import org.openstreetmap.josm.spi.preferences.Config;
+import org.openstreetmap.josm.spi.preferences.MemoryPreferences;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Utils;
 …
   private TestUtil() {
     // Prevent instantiation
+  }
+  /**
+   * Check if we can load images
+   * @return {@code true} if the {@link StreetsidePlugin#LOGO} could be loaded
+   */
+  public static boolean cannotLoadImages() {
+    // The class-level @DisabledIf seems to be run prior to any possible setup code
+    if (Config.getPref() == null) {
+      Config.setPreferencesInstance(new MemoryPreferences());
+    }
+    return new ImageProvider("streetside-logo").setOptional(true).getResource() == null;
+  }

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/api/JsonDecoderTest.java

-              r34386
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils.api;
+import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import java.io.ByteArrayInputStream;
 …
 import javax.json.JsonObject;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.streetside.utils.TestUtil;
 public class JsonDecoderTest {
+class JsonDecoderTest {
   @Test
   public void testUtilityClass() {
+  void testUtilityClass() {
     TestUtil.testUtilityClass(JsonDecoder.class);
+  }
   @Test
   public void testDecodeDoublePair() {
+  void testDecodeDoublePair() {
     assertNull(JsonDecoder.decodeDoublePair(null));
+  }

applications/editors/josm/plugins/MicrosoftStreetside/test/unit/org/openstreetmap/josm/plugins/streetside/utils/api/JsonSequencesDecoderTest.java

-              r34432
+              r36064
 package org.openstreetmap.josm.plugins.streetside.utils.api;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.openstreetmap.josm.plugins.streetside.utils.api.JsonDecoderTest.assertDecodesToNull;
 …
 import javax.json.JsonValue;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.TestUtil;
 public class JsonSequencesDecoderTest {
   @Ignore
   @Test
   public void testDecodeSequences() {
+class JsonSequencesDecoderTest {
+  @Disabled
+  @Test
+  void testDecodeSequences() {
     Collection<StreetsideSequence> exampleSequences = JsonDecoder.decodeFeatureCollection(
       Json.createReader(this.getClass().getResourceAsStream("test/data/api/v3/responses/searchSequences.json")).readObject(),
 …
     assertEquals(329.94820000000004, seq.getImages().get(3).getHe(), 1e-10);
     assertEquals(new LatLon(7.246497, 16.432958),  seq.getImages().get(0).getLatLon());
     assertEquals(new LatLon(7.246567, 16.432955),  seq.getImages().get(1).getLatLon());
     assertEquals(new LatLon(7.248372, 16.432971),  seq.getImages().get(2).getLatLon());
     assertEquals(new LatLon(7.249027, 16.432976),  seq.getImages().get(3).getLatLon());
+    assertEquals(new LatLon(7.246497, 16.432958), seq.getImages().get(0).getLatLon());
+    assertEquals(new LatLon(7.246567, 16.432955), seq.getImages().get(1).getLatLon());
+    assertEquals(new LatLon(7.248372, 16.432971), seq.getImages().get(2).getLatLon());
+    assertEquals(new LatLon(7.249027, 16.432976), seq.getImages().get(3).getLatLon());
     assertEquals(1_457_963_093_860L, seq.getCd()); // 2016-03-14T13:44:53.860 UTC
 …
   @Test
   public void testDecodeSequencesInvalid() {
+  void testDecodeSequencesInvalid() {
     // null input
     assertEquals(0, JsonDecoder.decodeFeatureCollection(null, JsonSequencesDecoder::decodeSequence).size());
 …
   @Test
   public void testDecodeSequencesWithArbitraryObjectAsFeature() {
+  void testDecodeSequencesWithArbitraryObjectAsFeature() {
     assertNumberOfDecodedSequences(0, "{\"type\": \"FeatureCollection\", \"features\": [{}]}");
+  }
   private static void assertNumberOfDecodedSequences(int expectedNumberOfSequences, String jsonString) {
+    assertEquals(
+      expectedNumberOfSequences,
+      JsonDecoder.decodeFeatureCollection(
+        Json.createReader(new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8))).readObject(),
+        JsonSequencesDecoder::decodeSequence
+      ).size()
+    );
+  }
+  @Ignore
+  @Test
+  public void testDecodeSequence() {
+    assertEquals(expectedNumberOfSequences, JsonDecoder.decodeFeatureCollection(
+      Json.createReader(new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8))).readObject(),
+      JsonSequencesDecoder::decodeSequence
+    ).size());
+  }
+  @Disabled
+  @Test
+  void testDecodeSequence() {
     StreetsideSequence exampleSequence = JsonSequencesDecoder.decodeSequence(
       Json.createReader(this.getClass().getResourceAsStream("/api/v3/responses/sequence.json")).readObject()
 …
     assertEquals(2, exampleSequence.getImages().size());
+    assertEquals(
+      new StreetsideImage("76P0YUrlDD_lF6J7Od3yoA", new LatLon(16.43279, 7.246085), 96.71454),
+      exampleSequence.getImages().get(0)
+    );
+    assertEquals(
+      new StreetsideImage("Ap_8E0BwoAqqewhJaEbFyQ", new LatLon(16.432799, 7.246082), 96.47705000000002),
+      exampleSequence.getImages().get(1)
+    );
+  }
+  @Test
+  public void testDecodeSequenceInvalid() {
+    assertEquals(new StreetsideImage("76P0YUrlDD_lF6J7Od3yoA", new LatLon(16.43279, 7.246085), 96.71454), exampleSequence.getImages().get(0));
+    assertEquals(new StreetsideImage("Ap_8E0BwoAqqewhJaEbFyQ", new LatLon(16.432799, 7.246082), 96.47705000000002), exampleSequence.getImages().get(1));
+  }
+  @Test
+  void testDecodeSequenceInvalid() {
     // null input
     assertNull(JsonSequencesDecoder.decodeSequence(null));
+    Assertions.assertNull(JsonSequencesDecoder.decodeSequence(null));
     // `properties` key is not set
     assertDecodesToNull(JsonSequencesDecoder::decodeSequence, "{\"type\": \"Feature\"}");
 …
    */
   @Test
   public void testDecodeJsonArray()
+  void testDecodeJsonArray()
       throws NoSuchMethodException, SecurityException, IllegalAccessException,
       IllegalArgumentException, InvocationTargetException {
     Method method = JsonSequencesDecoder.class.getDeclaredMethod("decodeJsonArray", JsonArray.class, Function.class, Class.class);
     method.setAccessible(true);
+    assertEquals(
+,
+      ((String[]) method.invoke(null, null, (Function<JsonValue, String>) val -> null, String.class)).length
+    );
+  }
+  @Test
+  public void testDecodeCoordinateProperty() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+    assertEquals(0, ((String[]) method.invoke(null, null, (Function<JsonValue, String>) val -> null, String.class)).length);
+  }
+  @Test
+  void testDecodeCoordinateProperty() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
     Method decodeCoordinateProperty = JsonSequencesDecoder.class.getDeclaredMethod(
       "decodeCoordinateProperty",
 …
     decodeCoordinateProperty.setAccessible(true);
+    assertEquals(
+,
+      ((String[]) decodeCoordinateProperty.invoke(
+        null, null, "key", (Function<JsonValue, String>) val -> "string", String.class
+      )).length
+    );
+    assertEquals(
+,
+      ((String[]) decodeCoordinateProperty.invoke(
+        null, JsonUtil.string2jsonObject("{\"coordinateProperties\":{\"key\":0}}"), "key", (Function<JsonValue, String>) val -> "string", String.class
+      )).length
+    );
+  }
+  @Test
+  public void testDecodeLatLons()
+    assertEquals(0, ((String[]) decodeCoordinateProperty.invoke(
+      null, null, "key", (Function<JsonValue, String>) val -> "string", String.class
+    )).length);
+    assertEquals(0, ((String[]) decodeCoordinateProperty.invoke(
+      null, JsonUtil.string2jsonObject("{\"coordinateProperties\":{\"key\":0}}"), "key", (Function<JsonValue, String>) val -> "string", String.class
+    )).length);
+  }
+  @Test
+  void testDecodeLatLons()
       throws NoSuchMethodException, SecurityException, IllegalAccessException,
       IllegalArgumentException, InvocationTargetException {
 …
     )).readObject());
     assertEquals(3, example.length);
     assertNull(example[0]);
     assertNull(example[1]);
     assertNull(example[2]);
+  }
   @Test
   public void testUtilityClass() {
+    Assertions.assertNull(example[0]);
+    Assertions.assertNull(example[1]);
+    Assertions.assertNull(example[2]);
+  }
+  @Test
+  void testUtilityClass() {
     TestUtil.testUtilityClass(JsonSequencesDecoder.class);
+  }

applications/editors/josm/plugins/alignways/test/unit/org/openstreetmap/josm/plugins/alignways/geometry/AlignWaysGeomLineTest.java

-              r34489
+              r36064
 package org.openstreetmap.josm.plugins.alignways.geometry;
-import static org.junit.Assert.assertTrue;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.alignways.geometry.AlignWaysGeomLine.IntersectionStatus;
 …
  * Tests of {@link AlignWaysGeomLine}
  */
 public class AlignWaysGeomLineTest {
+class AlignWaysGeomLineTest {
     private AlignWaysGeomLine line_x1y1x2y2, line_par_x1y1x2y2;
     private AlignWaysGeomLine line_abc;
 …
     private AlignWaysGeomLine line_horiz, line_vert;
     @Before
     public void setUp() {
+    @BeforeEach
+    void setUp() {
         line_x1y1x2y2 = new AlignWaysGeomLine(-2.0, -1.0, 4.0, 3.0);
         line_abc = new AlignWaysGeomLine(2.0/3, -1.0, 1.0/3);
 …
     @Test
     public void LineLineEquiv() {
         assertTrue(line_x1y1x2y2.equals(line_line));
+    void testLineLineEquiv() {
+        assertEquals(line_x1y1x2y2, line_line);
+    }
     @Test
     public void LineAbcLineEquiv() {
         assertTrue(line_x1y1x2y2.equals(line_abc));
+    void testLineAbcLineEquiv() {
+        assertEquals(line_x1y1x2y2, line_abc);
+    }
     @Test
     public void LineMbLineEquiv() {
         assertTrue(line_x1y1x2y2.equals(line_mb));
+    void testLineMbLineEquiv() {
+        assertEquals(line_x1y1x2y2, line_mb);
+    }
     @Test
     public void LineAbcMbEquiv() {
         assertTrue(line_abc.equals(line_mb));
+    void testLineAbcMbEquiv() {
+        assertEquals(line_abc, line_mb);
+    }
     @Test
     public void LineLineParallel() {
+    void testLineLineParallel() {
         line_x1y1x2y2.getIntersection(line_par_x1y1x2y2);
         assertTrue(line_x1y1x2y2.getIntersectionStatus() == IntersectionStatus.LINES_PARALLEL);
+        assertSame(line_x1y1x2y2.getIntersectionStatus(), IntersectionStatus.LINES_PARALLEL);
+    }
     @Test
     public void LineAbcOverlap() {
+    void testLineAbcOverlap() {
         line_x1y1x2y2.getIntersection(line_abc);
         assertTrue(line_x1y1x2y2.getIntersectionStatus() == IntersectionStatus.LINES_OVERLAP);
+        assertSame(line_x1y1x2y2.getIntersectionStatus(), IntersectionStatus.LINES_OVERLAP);
+    }
     @Test
     public void LineMbOverlap() {
+    void testLineMbOverlap() {
         line_x1y1x2y2.getIntersection(line_mb);
         assertTrue(line_x1y1x2y2.getIntersectionStatus() == IntersectionStatus.LINES_OVERLAP);
+        assertSame(line_x1y1x2y2.getIntersectionStatus(), IntersectionStatus.LINES_OVERLAP);
+    }
     @Test
     public void AbcMbOverlap() {
+    void testAbcMbOverlap() {
         line_abc.getIntersection(line_mb);
         assertTrue(line_abc.getIntersectionStatus() == IntersectionStatus.LINES_OVERLAP);
+        assertSame(line_abc.getIntersectionStatus(), IntersectionStatus.LINES_OVERLAP);
+    }
     @Test
     public void GetXOnHoriz() {
+    void testGetXOnHoriz() {
         assertTrue(line_horiz.getXonLine(2.0).isNaN());
+    }
     @Test
     public void GetYOnVert() {
+    void testGetYOnVert() {
         assertTrue(line_vert.getYonLine(2.0).isNaN());
+    }
     @Test
     public void StatusUndefAfterConstruct() throws Exception {
+    void testStatusUndefAfterConstruct() {
         AlignWaysGeomLine newLine = new AlignWaysGeomLine(1.0, 2.0);
+        assertTrue(newLine.getIntersectionStatus() == IntersectionStatus.UNDEFINED);
+        assertSame(newLine.getIntersectionStatus(), IntersectionStatus.UNDEFINED);
+    }

applications/editors/josm/plugins/cadastre-fr/test/unit/org/openstreetmap/josm/plugins/fr/cadastre/edigeo/EdigeoRecordTest.java

-              r33773
+              r36064
 package org.openstreetmap.josm.plugins.fr.cadastre.edigeo;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.Arrays;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.plugins.fr.cadastre.edigeo.EdigeoRecord.Format;
 …
  * Unit test of {@link EdigeoRecord}.
  */
 public class EdigeoRecordTest {
+class EdigeoRecordTest {
     /**
 …
      */
     @Test
     public void testEdigeoRecord() {
+    void testEdigeoRecord() {
         EdigeoRecord r = new EdigeoRecord("SCPCP27:TEST01;SeSD;OBJ;PARCELLE_id");
         assertEquals("SCP", r.name);
 …
      */
     @Test
     public void testEqualsContract() {
+    void testEqualsContract() {
         TestUtils.assumeWorkingEqualsVerifier();
         EqualsVerifier.forClass(EdigeoRecord.class).usingGetClass()

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/AsyncEventBusTest.java

-              r34000
+              r36064
 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;
 …
 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;
 /**
 …
  * @author Cliff Biffle
  */
 public class AsyncEventBusTest {
+class AsyncEventBusTest {
   private static final String EVENT = "Hello";
 …
   private AsyncEventBus bus;
   @Before
   public void setUp() throws Exception {
+  @BeforeEach
+  void setUp() {
     executor = new FakeExecutor();
     bus = new AsyncEventBus(executor);
 …
   @Test
   public void testBasicDistribution() {
+  void testBasicDistribution() {
     StringCatcher catcher = new StringCatcher();
     bus.register(catcher);
 …
     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.");
+  }

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/DispatcherTest.java

-              r34000
+              r36064
 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;
 /**
 …
  */
 public class DispatcherTest {
+class DispatcherTest {
   private final EventBus bus = new EventBus();
 …
   @Test
   @Ignore("FIXME")
   public void testPerThreadQueuedDispatcher() {
+  @Disabled("FIXME")
+  void testPerThreadQueuedDispatcher() {
     dispatcher = Dispatcher.perThreadDispatchQueue();
     dispatcher.dispatch(1, integerSubscribers.iterator());
 …
   @Test
   @Ignore("FIXME")
   public void testLegacyAsyncDispatcher() {
+  @Disabled("FIXME")
+  void testLegacyAsyncDispatcher() {
     dispatcher = Dispatcher.legacyAsync();
 …
     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();
 …
   @Test
   @Ignore("FIXME")
   public void testImmediateDispatcher() {
+  @Disabled("FIXME")
+  void testImmediateDispatcher() {
     dispatcher = Dispatcher.immediate();
     dispatcher.dispatch(1, integerSubscribers.iterator());

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/EventBusTest.java

-              r34000
+              r36064
 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;
 …
 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;
 /**
 …
  * @author Cliff Biffle
  */
 public class EventBusTest {
+class EventBusTest {
   private static final String EVENT = "Hello";
   private static final String BUS_IDENTIFIER = "test-bus";
 …
   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);
 …
     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.");
+  }
 …
    */
   @Test
   public void testPolymorphicDistribution() {
+  void testPolymorphicDistribution() {
     // Three catchers for related types String, Object, and Comparable<?>.
     // String isa Object
 …
     // 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);
 …
     // 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);
 …
     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() {
 …
         };
     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);
 …
     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);
 …
     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);
 …
     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.");
+  }
 …
   @Test
   public void testRegisterThreadSafety() throws Exception {
+  void testRegisterThreadSafety() throws Exception {
     List<StringCatcher> catchers = new CopyOnWriteArrayList<>();
     List<Future<?>> futures = new ArrayList<>();
 …
       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());
 …
    */
   @Test
   public void testRegistrationWithBridgeMethod() {
+  void testRegistrationWithBridgeMethod() {
     final AtomicInteger calls = new AtomicInteger();
     bus.register(
 …
    */
   public static class GhostCatcher {
     private List<DeadEvent> events = new ArrayList<>();
+    private final List<DeadEvent> events = new ArrayList<>();
     @Subscribe

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/ReentrantEventsTest.java

-              r34000
+              r36064
 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;
 …
 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;
 /**
 …
  * @author Jesse Wilson
  */
 public class ReentrantEventsTest {
+class ReentrantEventsTest {
   static final String FIRST = "one";
 …
   @Test
   public void testNoReentrantEvents() {
+  void testNoReentrantEvents() {
     ReentrantEventsHater hater = new ReentrantEventsHater();
     bus.register(hater);
 …
     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");
+  }
 …
     @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);
+    }
 …
   @Test
   public void testEventOrderingIsPredictable() {
+  void testEventOrderingIsPredictable() {
     EventProcessor processor = new EventProcessor();
     bus.register(processor);
 …
     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");
+  }

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/StringCatcher.java

-              r34000
+              r36064
 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;
 /**
 …
  */
 public class StringCatcher {
   private List<String> events = new ArrayList<>();
+  private final List<String> events = new ArrayList<>();
   @Subscribe

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberRegistryTest.java

-              r34000
+              r36064
 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;
 …
 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;
 /**
 …
   @Test
   public void testRegister() {
+  void testRegister() {
     assertEquals(0, registry.getSubscribersForTesting(String.class).size());
 …
   @Test
   public void testUnregister() {
+  void testUnregister() {
     StringSubscriber s1 = new StringSubscriber();
     StringSubscriber s2 = new StringSubscriber();
 …
   @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("")));
 …
   @Test
   @Ignore("FIXME")
   public void testGetSubscribers_returnsImmutableSnapshot() {
+  @Disabled("FIXME")
+  void testGetSubscribersReturnsImmutableSnapshot() {
     StringSubscriber s1 = new StringSubscriber();
     StringSubscriber s2 = new StringSubscriber();
 …
   @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));
+  }

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/SubscriberTest.java

-              r34000
+              r36064
 //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;
 /**
 …
  * @author Colin Decker
  */
 public class SubscriberTest extends TestCase {
+class SubscriberTest {
   private static final Object FIXTURE_ARGUMENT = new Object();
 …
   private Object methodArgument;
   @Override
   protected void setUp() throws Exception {
+  @BeforeEach
+  protected void setUp() {
     bus = new EventBus();
     methodCalled = false;
 …
   @Test
   public void testCreate() {
+  void testCreate() {
     Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod"));
     assertTrue(s1 instanceof Subscriber.SynchronizedSubscriber);
 …
     // 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);
 …
     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);
 …
   @Subscribe
   public void recordingMethod(Object arg) {
     assertFalse(methodCalled);
+    Assertions.assertFalse(methodCalled);
     methodCalled = true;
     methodArgument = arg;
 …
   /** Local exception subclass to check variety of exception thrown. */
   class IntentionalException extends Exception {
+  static class IntentionalException extends Exception {
     private static final long serialVersionUID = -2500191180248181379L;

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/AnnotatedSubscriberFinderTests.java

-              r34000
+              r36064
 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;
 …
+    }
     @Before
     public void setUp() throws Exception {
+    @BeforeEach
+    public void setUp() {
       subscriber = createSubscriber();
       EventBus bus = new EventBus();
 …
+    }
     @After
     public void tearDown() throws Exception {
+    @AfterEach
+    public void tearDown() {
       subscriber = null;
+    }
 …
    * 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 {
 …
     @Test
     public void testNonSubscriber() {
+    void testNonSubscriber() {
       assertTrue(getSubscriber().nonSubscriberEvents.isEmpty());
+    }
     @Test
     public void testSubscriber() {
+    void testSubscriber() {
       assertTrue(getSubscriber().subscriberEvents.contains(EVENT));
+    }
 …
+  }
   public static class AnnotatedAndAbstractInSuperclassTest
+  static class AnnotatedAndAbstractInSuperclassTest
       extends AbstractEventBusTestParent<AnnotatedAndAbstractInSuperclassTest.SubClass> {
     abstract static class SuperClass {
 …
     @Test
     public void testOverriddenAndAnnotatedInSubclass() {
+    void testOverriddenAndAnnotatedInSubclass() {
       assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT));
+    }
     @Test
     public void testOverriddenNotAnnotatedInSubclass() {
+    void testOverriddenNotAnnotatedInSubclass() {
       assertTrue(getSubscriber().overriddenInSubclassEvents.contains(EVENT));
+    }
 …
+  }
   public static class AnnotatedNotAbstractInSuperclassTest
+  static class AnnotatedNotAbstractInSuperclassTest
       extends AbstractEventBusTestParent<AnnotatedNotAbstractInSuperclassTest.SubClass> {
     static class SuperClass {
 …
     @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));
 …
     @Test
     public void testOverriddenAndAnnotatedInSubclass() {
+    void testOverriddenAndAnnotatedInSubclass() {
       assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT));
+    }
     @Test
     public void testDifferentlyOverriddenAndAnnotatedInSubclass() {
+    void testDifferentlyOverriddenAndAnnotatedInSubclass() {
       assertTrue(getSubscriber().differentlyOverriddenAnnotatedInSubclassGoodEvents
           .contains(EVENT));
 …
+  }
   public static class AbstractNotAnnotatedInSuperclassTest
+  static class AbstractNotAnnotatedInSuperclassTest
       extends AbstractEventBusTestParent<AbstractNotAnnotatedInSuperclassTest.SubClass> {
     abstract static class SuperClass {
 …
     @Test
     public void testOverriddenAndAnnotatedInSubclass() {
+    void testOverriddenAndAnnotatedInSubclass() {
       assertTrue(getSubscriber().overriddenAndAnnotatedInSubclassEvents.contains(EVENT));
+    }
     @Test
     public void testOverriddenInSubclassNowhereAnnotated() {
+    void testOverriddenInSubclassNowhereAnnotated() {
       assertTrue(getSubscriber().overriddenInSubclassNowhereAnnotatedEvents.isEmpty());
+    }
 …
+  }
   public static class NeitherAbstractNorAnnotatedInSuperclassTest
+  static class NeitherAbstractNorAnnotatedInSuperclassTest
       extends AbstractEventBusTestParent<NeitherAbstractNorAnnotatedInSuperclassTest.SubClass> {
     static class SuperClass {
 …
     @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));
+    }
 …
+  }
   public static class DeepInterfaceTest
+  static class DeepInterfaceTest
       extends AbstractEventBusTestParent<DeepInterfaceTest.SubscriberClass> {
     interface Interface1 {
 …
     @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());
+    }

applications/editors/josm/plugins/eventbus/test/unit/org/openstreetmap/josm/eventbus/outside/OutsideEventBusTest.java

-              r34000
+              r36064
 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;
 …
  * @author Louis Wasserman
  */
 public class OutsideEventBusTest {
+class OutsideEventBusTest {
   /*
 …
    */
   @Test
   public void testAnonymous() {
+  void testAnonymous() {
     final AtomicReference<String> holder = new AtomicReference<>();
     final AtomicInteger deliveries = new AtomicInteger();
 …
     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.");
+  }
+}

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/FullGraphCreationTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core;
+import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 …
 import java.util.Map;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.graphview.core.TestDataSource.TestNode;
 import org.openstreetmap.josm.plugins.graphview.core.TestDataSource.TestRelation;
 …
 import org.openstreetmap.josm.plugins.graphview.plugin.preferences.VehiclePropertyStringParser.PropertyValueSyntaxException;
 public class FullGraphCreationTest {
+class FullGraphCreationTest {
     private static final AccessParameters ACCESS_PARAMS;
 …
             ACCESS_PARAMS = new PreferenceAccessParameters(
                     "test_vehicle",
                     Arrays.asList(AccessType.UNDEFINED),
+                    Collections.singletonList(AccessType.UNDEFINED),
                     vehiclePropertyValues);
         } catch (PropertyValueSyntaxException e) {
 …
         @Override
         public java.util.List<String> getAccessHierarchyAncestors(String transportMode) {
             return Arrays.asList(transportMode);
+            return Collections.singletonList(transportMode);
+        }
         @Override
         public Collection<Tag> getBaseTags() {
             return Arrays.asList(new Tag("highway", "test"));
+            return Collections.singletonList(new Tag("highway", "test"));
+        }
 …
     @Test
     public void testTJunction() {
+    void testTJunction() {
         TestDataSource ds = new TestDataSource();
 …
     @Test
     public void testBarrier() {
+    void testBarrier() {
         TestDataSource ds = new TestDataSource();

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/access/AccessRulesetReaderTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.access;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.io.FileInputStream;
 …
 import java.util.Map;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.plugins.graphview.core.data.MapBasedTagGroup;
 …
 import org.openstreetmap.josm.plugins.graphview.core.data.TagGroup;
 public class AccessRulesetReaderTest {
+class AccessRulesetReaderTest {
     @Test
     public void testReadAccessRuleset_valid_classes() throws IOException {
+    void testReadAccessRulesetValidClasses() throws IOException {
         InputStream is = new FileInputStream(TestUtils.getTestDataRoot()+"accessRuleset_valid.xml");
 …
     @Test
     public void testReadAccessRuleset_valid_basetags() throws IOException {
+    void testReadAccessRulesetValidBasetags() throws IOException {
         InputStream is = new FileInputStream(TestUtils.getTestDataRoot()+"accessRuleset_valid.xml");
 …
     @Test
     public void testReadAccessRuleset_valid_implications() throws IOException {
+    void testReadAccessRulesetValidImplications() throws IOException {
         InputStream is = new FileInputStream(TestUtils.getTestDataRoot()+"accessRuleset_valid.xml");

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/property/RoadInclineTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.property;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.graphview.core.data.Tag;
 public class RoadInclineTest extends RoadPropertyTest {
+class RoadInclineTest implements RoadPropertyTest {
     private static void testIncline(Float expectedInclineForward, Float expectedInclineBackward,
             String inclineString) {
         testEvaluateW(new RoadIncline(),
+        RoadPropertyTest.testEvaluateW(new RoadIncline(),
                 expectedInclineForward, expectedInclineBackward,
                 new Tag("incline", inclineString));
 …
     @Test
     public void testEvaluate() {
+    void testEvaluate() {
         testIncline(5f, -5f, "5 %");
         testIncline(9.5f, -9.5f, "9.5 %");

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/property/RoadMaxspeedTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.property;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.graphview.core.data.Tag;
 public class RoadMaxspeedTest extends RoadPropertyTest {
+class RoadMaxspeedTest implements RoadPropertyTest {
     private static void testMaxspeed(float expectedMaxspeed, String maxspeedString) {
         testEvaluateBoth(new RoadMaxspeed(), expectedMaxspeed, new Tag("maxspeed", maxspeedString));
+        RoadPropertyTest.testEvaluateBoth(new RoadMaxspeed(), expectedMaxspeed, new Tag("maxspeed", maxspeedString));
+    }
     @Test
     public void testEvaluate_numeric() {
+    void testEvaluateNumeric() {
         testMaxspeed(30, "30");
         testMaxspeed(48.3f, "48.3");
 …
     @Test
     public void testEvaluate_kmh() {
+    void testEvaluateKmh() {
         testMaxspeed(50, "50 km/h");
         testMaxspeed(120, "120km/h");
 …
     @Test
     public void testEvaluate_mph() {
+    void testEvaluateMph() {
         testMaxspeed(72.42048f, "45 mph");
         testMaxspeed(64.373764f, "40mph");

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/property/RoadPropertyTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.property;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.Ignore;
 import org.openstreetmap.josm.plugins.graphview.core.TestDataSource;
 import org.openstreetmap.josm.plugins.graphview.core.data.Tag;
+@Ignore("no test")
+public abstract class RoadPropertyTest {
+public interface RoadPropertyTest {
     protected static <P> void testEvaluateW(RoadPropertyType<P> property, P expectedForward, P expectedBackward, Tag... wayTags) {
+    static <P> void testEvaluateW(RoadPropertyType<P> property, P expectedForward, P expectedBackward, Tag... wayTags) {
         TestDataSource ds = new TestDataSource();
 …
+    }
     protected static <P> void testEvaluateN(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
+    static <P> void testEvaluateN(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
         TestDataSource ds = new TestDataSource();
 …
+    }
     protected static <P> void testEvaluateBoth(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
+    static <P> void testEvaluateBoth(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
         testEvaluateW(property, expected, expected, nodeTags);
         testEvaluateN(property, expected, nodeTags);

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/util/TagConditionLogicTest.java

-              r32620
+              r36064
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.graphview.core.util;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.graphview.core.data.MapBasedTagGroup;
 import org.openstreetmap.josm.plugins.graphview.core.data.Tag;
 import org.openstreetmap.josm.plugins.graphview.core.data.TagGroup;
 public class TagConditionLogicTest {
+class TagConditionLogicTest {
     TagGroup groupA;
     TagGroup groupB;
     @Before
     public void setUp() {
+    @BeforeEach
+    void setUp() {
         Map<String, String> mapA = new HashMap<>();
         mapA.put("key1", "value1");
 …
     @Test
     public void testTag() {
+    void testTag() {
         TagCondition condition = TagConditionLogic.tag(new Tag("key3", "value1"));
         assertTrue(condition.matches(groupA));
 …
     @Test
     public void testKey() {
+    void testKey() {
         TagCondition condition = TagConditionLogic.key("key3");
         assertTrue(condition.matches(groupA));
 …
     @Test
     public void testAnd() {
+    void testAnd() {
         TagCondition condition1 = TagConditionLogic.tag(new Tag("key2", "value2"));
         TagCondition conditionAnd1a = TagConditionLogic.and(condition1);
         TagCondition conditionAnd1b = TagConditionLogic.and(Arrays.asList(condition1));
+        TagCondition conditionAnd1b = TagConditionLogic.and(Collections.singletonList(condition1));
         assertTrue(conditionAnd1a.matches(groupA));
 …
     @Test
     public void testOr() {
+    void testOr() {
         TagCondition condition1 = TagConditionLogic.tag(new Tag("key42", "value42"));
         TagCondition conditionOr1a = TagConditionLogic.or(condition1);
         TagCondition conditionOr1b = TagConditionLogic.or(Arrays.asList(condition1));
+        TagCondition conditionOr1b = TagConditionLogic.or(Collections.singletonList(condition1));
         assertFalse(conditionOr1a.matches(groupA));
 …
     @Test
     public void testNot() {
+    void testNot() {
         TagCondition condition = TagConditionLogic.not(TagConditionLogic.key("key3"));
         assertFalse(condition.matches(groupA));

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/util/ValueStringParserTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.util;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.openstreetmap.josm.plugins.graphview.core.util.ValueStringParser.parseMeasure;
 import static org.openstreetmap.josm.plugins.graphview.core.util.ValueStringParser.parseSpeed;
 import static org.openstreetmap.josm.plugins.graphview.core.util.ValueStringParser.parseWeight;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+public class ValueStringParserTest {
+class ValueStringParserTest {
     /* speed */
     @Test
     public void testParseSpeedDefault() {
+    void testParseSpeedDefault() {
         assertClose(50, parseSpeed("50"));
+    }
     @Test
     public void testParseSpeedKmh() {
+    void testParseSpeedKmh() {
         assertClose(30, parseSpeed("30 km/h"));
         assertClose(100, parseSpeed("100km/h"));
 …
     @Test
     public void testParseSpeedMph() {
+    void testParseSpeedMph() {
         assertClose(40.234f, parseSpeed("25mph"));
         assertClose(40.234f, parseSpeed("25 mph"));
 …
     @Test
     public void testParseSpeedInvalid() {
+    void testParseSpeedInvalid() {
         assertNull(parseSpeed("lightspeed"));
+    }
 …
     @Test
     public void testParseMeasureDefault() {
+    void testParseMeasureDefault() {
         assertClose(3.5f, parseMeasure("3.5"));
+    }
     @Test
     public void testParseMeasureM() {
+    void testParseMeasureM() {
         assertClose(2, parseMeasure("2m"));
         assertClose(5.5f, parseMeasure("5.5 m"));
 …
     @Test
     public void testParseMeasureKm() {
+    void testParseMeasureKm() {
         assertClose(1000, parseMeasure("1 km"));
         assertClose(7200, parseMeasure("7.2km"));
 …
     @Test
     public void testParseMeasureMi() {
+    void testParseMeasureMi() {
         assertClose(1609.344f, parseMeasure("1 mi"));
+    }
     @Test
     public void testParseMeasureFeetInches() {
+    void testParseMeasureFeetInches() {
         assertClose(3.6576f, parseMeasure("12'0\""));
         assertClose(1.9812f, parseMeasure("6' 6\""));
 …
     @Test
     public void testParseMeasureInvalid() {
+    void testParseMeasureInvalid() {
         assertNull(parseMeasure("very long"));
         assertNull(parseMeasure("6' 16\""));
 …
     @Test
     public void testParseWeightDefault() {
+    void testParseWeightDefault() {
         assertClose(3.6f, parseWeight("3.6"));
+    }
     @Test
     public void testParseWeightT() {
+    void testParseWeightT() {
         assertClose(30, parseWeight("30t"));
         assertClose(3.5f, parseWeight("3.5 t"));
 …
     @Test
     public void testParseWeightInvalid() {
+    void testParseWeightInvalid() {
         assertNull(parseWeight("heavy"));
+    }

applications/editors/josm/plugins/graphview/test/unit/org/openstreetmap/josm/plugins/graphview/core/visualisation/FloatPropertyColorSchemeTest.java

-              r32620
+              r36064
 package org.openstreetmap.josm.plugins.graphview.core.visualisation;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.awt.Color;
 …
 import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.plugins.graphview.core.property.RoadMaxweight;
 public class FloatPropertyColorSchemeTest {
+class FloatPropertyColorSchemeTest {
     private FloatPropertyColorScheme subject;
     @Before
+    @BeforeEach
     public void setUp() {
 …
     @Test
     public void testGetColorForValue_below() {
+    void testGetColorForValueBelow() {
         assertEquals(new Color(42, 42, 42), subject.getColorForValue(1f));
         assertEquals(new Color(42, 42, 42), subject.getColorForValue(5f));
 …
     @Test
     public void testGetColorForValue_above() {
+    void testGetColorForValueAbove() {
         assertEquals(new Color(200, 200, 200), subject.getColorForValue(25f));
+    }
     @Test
     public void testGetColorForValue_value() {
+    void testGetColorForValueValue() {
         assertEquals(new Color(100, 100, 100), subject.getColorForValue(10f));
+    }
     @Test
     public void testGetColorForValue_interpolate() {
+    void testGetColorForValueInterpolate() {
         assertEquals(new Color(150, 150, 150), subject.getColorForValue(15f));
+    }

applications/editors/josm/plugins/http2/test/unit/org/openstreetmap/josm/plugins/http2/Http2ClientTest.java

-              r35790
+              r36064
 package org.openstreetmap.josm.plugins.http2;
+import static org.junit.Assert.assertEquals;
+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 static org.junit.jupiter.api.Assertions.assertTrue;
 …
     @Test
     void testCreateRequest_invalidURI() throws Exception {
+    void testCreateRequestInvalidURI() {
         // From https://josm.openstreetmap.de/ticket/21126
         // URISyntaxException for URL not formatted strictly according to RFC2396
         // See chapter "2.4.3. Excluded US-ASCII Characters"
         assertTrue(assertThrows(IOException.class, () -> new Http2Client(
                 new URL("https://commons.wikimedia.org/w/api.php?format=xml&action=query&list=geosearch&gsnamespace=6&gslimit=500&gsprop=type|name&gsbbox=52.2804692|38.1772755|52.269721|38.2045051"), "GET")
+        final URL url = assertDoesNotThrow(() -> new URL("https://commons.wikimedia.org/w/api.php?format=xml&action=query&list=geosearch&gsnamespace=6&gslimit=500&gsprop=type|name&gsbbox=52.2804692|38.1772755|52.269721|38.2045051"));
+        assertTrue(assertThrows(IOException.class, () -> new Http2Client(url, "GET")
                 .createRequest()).getCause().getMessage().startsWith("Illegal character in query at index 116:"));
+    }

applications/editors/josm/plugins/imagery-xml-bounds/test/unit/org/openstreetmap/josm/plugins/imageryxmlbounds/actions/ComputeBoundsActionTest.java

-              r35100
+              r36064
 package org.openstreetmap.josm.plugins.imageryxmlbounds.actions;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.Arrays;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit tests of {@link ComputeBoundsAction}
  */
+public class ComputeBoundsActionTest {
+    /**
+     * Setup rule
+     */
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules();
+@BasicPreferences
+class ComputeBoundsActionTest {
     /**
      * Unit test of {@link ComputeBoundsAction#getBounds}
      */
     @Test
     public void testGetBounds() {
+    void testGetBounds() {
         assertEquals("        <bounds min-lat='0' min-lon='0' max-lat='0' max-lon='0'>\n",
                 ComputeBoundsAction.getBounds(new Node(LatLon.ZERO), false));

applications/editors/josm/plugins/o5m/test/unit/org/openstreetmap/josm/plugins/o5m/io/O5mImporterTest.java

-              r34837
+              r36064
 package org.openstreetmap.josm.plugins.o5m.io;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import java.io.IOException;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.data.osm.User;
 import org.openstreetmap.josm.io.IllegalDataException;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit tests for {@link O5mImporter}.
  */
+public class O5mImporterTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class O5mImporterTest {
     private static void checkUserNull(OsmPrimitive osm, boolean hasToBeNull) {
         User usr = osm.getUser();
         if (hasToBeNull) {
             assertNull(osm + " -> " + usr, usr);
+            assertNull(usr, osm + " -> " + usr);
         } else {
             assertNotNull(osm + " -> " + usr, usr);
+            assertNotNull(usr, osm + " -> " + usr);
+        }
+    }
 …
      */
     @Test
     public void testParseDataSet() throws Exception {
+    void testParseDataSet() throws Exception {
         doTestMonaco(TestUtils.getTestDataRoot() + "/monaco-latest.o5m", false);
+    }
 …
      */
     @Test
     public void testParseDataSetDropVersion() throws Exception {
+    void testParseDataSetDropVersion() throws Exception {
         doTestMonaco(TestUtils.getTestDataRoot() + "/monaco-drop-version.o5m", true);
+    }

applications/editors/josm/plugins/opendata/modules/fr.toulouse/test/unit/org/openstreetmap/josm/plugins/opendata/modules/fr/toulouse/ToulouseModuleTest.java

-              r35269
+              r36064
 package org.openstreetmap.josm.plugins.opendata.modules.fr.toulouse;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit tests of {@link ToulouseModule} class.
  */
+public class ToulouseModuleTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class ToulouseModuleTest {
     @Test
     public void testHandlersConstruction() {
+    void testHandlersConstruction() {
         ToulouseModule module = new ToulouseModule(null);
         assertFalse(module.getHandlers().isEmpty());

applications/editors/josm/plugins/opendata/modules/fr.toulouse/test/unit/org/openstreetmap/josm/plugins/opendata/modules/fr/toulouse/ToulouseModuleTestIT.java

-              r35272
+              r36064
 package org.openstreetmap.josm.plugins.opendata.modules.fr.toulouse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.io.IOException;
 …
 import java.util.TreeMap;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.plugins.opendata.core.datasets.AbstractDataSetHandler;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 import org.openstreetmap.josm.tools.HttpClient;
 …
  * Integration tests of {@link ToulouseModule} class.
  */
+public class ToulouseModuleTestIT {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences().timeout(30_000);
+@BasicPreferences
+@Timeout(30)
+class ToulouseModuleTestIT {
     @Test
     public void testUrlValidity() throws IOException {
+    void testUrlValidity() throws IOException {
         Map<String, Integer> errors = new TreeMap<>();
         for (AbstractDataSetHandler handler : new ToulouseModule(null).getNewlyInstanciatedHandlers()) {
 …
+            }
+        }
         assertTrue(errors.toString(), errors.isEmpty());
+        assertTrue(errors.isEmpty(), errors.toString());
+    }
+}

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/archive/ZipReaderTest.java

-              r35899
+              r36064
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.InputStream;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Map.Entry;
+import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 import org.openstreetmap.josm.tools.Logging;
 …
  */
 @BasicPreferences
+@Projection
+@Timeout(value = 10, unit = TimeUnit.MINUTES)
 class ZipReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    public JOSMTestRules rules = new JOSMTestRules().projection().noTimeout();
     /**
      * Test for various zip files reading
 …
             File zipfile = p.toFile();
             Logging.info("Testing reading file "+zipfile.getPath());
             try (InputStream is = new FileInputStream(zipfile)) {
+            try (InputStream is = Files.newInputStream(zipfile.toPath())) {
                 for (Entry<File, DataSet> entry : ZipReader.parseDataSets(is, null, null, false).entrySet()) {
                     String name = entry.getKey().getName();

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/datasets/DataSetUpdaterTest.java

-              r35899
+              r36064
 package org.openstreetmap.josm.plugins.opendata.core.io.datasets;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Predicate;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 …
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
+@Timeout(value = 1, unit = TimeUnit.MINUTES)
 class DataSetUpdaterTest {
 …
      */
     @RegisterExtension
     JOSMTestRules rules = new JOSMTestRules().projection().devAPI().timeout(60000);
+    JOSMTestRules rules = new JOSMTestRules().devAPI();
     /**
 …
     void testTicket11166() throws Exception {
         File file = new File(TestUtils.getRegressionDataFile(11166, "raba760dissJosm.zip"));
         try (InputStream is = new FileInputStream(file)) {
+        try (InputStream is = Files.newInputStream(file.toPath())) {
             Predicate<? super Way> p = w -> w.getNodesCount() >= 0.9 * OsmApi.getOsmApi().getCapabilities().getMaxWayNodes();
             DataSet ds = ZipReader.parseDataSet(is, null, null, false);

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/geographic/GmlReaderTest.java

-              r35899
+              r36064
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
+@Timeout(value = 1, unit = TimeUnit.MINUTES)
 class GmlReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection().timeout(60000);
     /**
      * Non-regression test for ticket <a href="https://josm.openstreetmap.de/ticket/11624">#11624</a>
 …
     void testTicket11624() throws Exception {
         File file = new File(TestUtils.getRegressionDataFile(11624, "temp3.gml"));
         try (InputStream is = new FileInputStream(file)) {
+        try (InputStream is = Files.newInputStream(file.toPath())) {
             for (Node n : GmlReader.parseDataSet(is, null, null).getNodes()) {
                 assertNotNull(n.getCoor(), n.toString());

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/geographic/KmlReaderTest.java

-              r35910
+              r36064
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
 class KmlReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection();
     /**
      * Unit test of {@link KmlReader#COLOR_PATTERN}

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/geographic/MifReaderTest.java

-              r35899
+              r36064
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.plugins.opendata.core.datasets.AbstractDataSetHandler;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
 class MifReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection();
     private static AbstractDataSetHandler newHandler(final String epsgCode) {
         AbstractDataSetHandler handler = new AbstractDataSetHandler() {

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/geographic/ShpReaderTest.java

-              r35899
+              r36064
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.opendata.core.io.geographic;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.InputStream;
-import java.util.Collection;
-import java.util.Objects;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
-import org.openstreetmap.josm.TestUtils;
-import org.openstreetmap.josm.data.coor.LatLon;
-import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.Way;
-import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
-import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 …
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
  * Unit tests of {@link ShpReader} class.
  */
 @BasicPreferences
+@Projection
+@Timeout(value = 1, unit = TimeUnit.MINUTES)
 class ShpReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection().timeout(60000);
     /**
      * Non-regression test for ticket <a href="https://josm.openstreetmap.de/ticket/12714">#12714</a>
 …
     void testTicket12714() throws Exception {
         File file = new File(TestUtils.getRegressionDataFile(12714, "linhas.shp"));
         try (InputStream is = new FileInputStream(file)) {
+        try (InputStream is = Files.newInputStream(file.toPath())) {
             for (Node n : ShpReader.parseDataSet(is, file, null, null).getNodes()) {
                 assertNotNull(n.getCoor(), n.toString());

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/geographic/TabReaderTest.java

-              r35899
+              r36064
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
+@Timeout(value = 1, unit = TimeUnit.MINUTES)
 class TabReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection().timeout(60000);
     /**
      * Non-regression test for ticket <a href="https://josm.openstreetmap.de/ticket/15159">#15159</a>
 …
     void testTicket15159() throws Exception {
         File file = new File(TestUtils.getRegressionDataFile(15159, "Sanisette.tab"));
         try (InputStream is = new FileInputStream(file)) {
+        try (InputStream is = Files.newInputStream(file.toPath())) {
             NonRegFunctionalTests.testGeneric("#15159", TabReader.parseDataSet(is, file, null, null));
+        }

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/tabular/CsvReaderTest.java

-              r35899
+              r36064
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.coor.EastNorth;
 …
 import org.openstreetmap.josm.plugins.opendata.core.datasets.AbstractDataSetHandler;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
 class CsvReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection();
     private static AbstractDataSetHandler newHandler(final String epsgCode) {
         AbstractDataSetHandler handler = new AbstractDataSetHandler() {

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/tabular/OdsReaderTest.java

-              r35899
+              r36064
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
 class OdsReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    JOSMTestRules rules = new JOSMTestRules().projection();
     /**

applications/editors/josm/plugins/opendata/test/unit/org/openstreetmap/josm/plugins/opendata/core/io/tabular/XlsReaderTest.java

-              r35899
+              r36064
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.opendata.core.io.tabular;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import java.io.InputStream;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.coor.EastNorth;
 …
 import org.openstreetmap.josm.plugins.opendata.core.datasets.AbstractDataSetHandler;
 import org.openstreetmap.josm.plugins.opendata.core.io.NonRegFunctionalTests;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.openstreetmap.josm.testutils.annotations.Projection;
 /**
 …
  */
 @BasicPreferences
+@Projection
 class XlsReaderTest {
-    /**
-     * Setup test.
-     */
-    @RegisterExtension
-    public JOSMTestRules rules = new JOSMTestRules().projection();
     private static AbstractDataSetHandler newHandler(final String epsgCode) {
         AbstractDataSetHandler handler = new AbstractDataSetHandler() {

applications/editors/josm/plugins/pbf/test/unit/org/openstreetmap/josm/plugins/pbf/io/PbfExporterTest.java

-              r32927
+              r36064
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.pbf.io;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import java.io.FileInputStream;
 …
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.io.Compression;
 import org.openstreetmap.josm.io.OsmReader;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit tests for {@link PbfExporter}.
  */
+public class PbfExporterTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences().timeout(20000);
+@BasicPreferences
+@Timeout(20)
+class PbfExporterTest {
     /**
      * Non-regression test for <a href="https://josm.openstreetmap.de/ticket/11169">Ticket #11169</a>.
 …
      */
     @Test
     public void testTicket11169() throws Exception {
+    void testTicket11169() throws Exception {
         try (InputStream is = Compression.ZIP.getUncompressedInputStream(
                 new FileInputStream(TestUtils.getRegressionDataFile(11169, "Portsmouth_Area.osm.zip")))) {
+                Files.newInputStream(Paths.get(TestUtils.getRegressionDataFile(11169, "Portsmouth_Area.osm.zip"))))) {
             DataSet ds = OsmReader.parseDataSet(is, null);
             Path out = Files.createTempFile("pbf-bug-11169", "pbf");
+            new PbfExporter().doSave(out.toFile(), new OsmDataLayer(ds, null, null));
+            PbfExporter exporter = new PbfExporter();
+            assertDoesNotThrow(() -> exporter.doSave(out.toFile(), new OsmDataLayer(ds, null, null)));
             Files.delete(out);
+        }

applications/editors/josm/plugins/pbf/test/unit/org/openstreetmap/josm/plugins/pbf/io/PbfImporterTest.java

-              r34848
+              r36064
 package org.openstreetmap.josm.plugins.pbf.io;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import java.io.IOException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.data.osm.User;
 import org.openstreetmap.josm.io.IllegalDataException;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit tests for {@link PbfImporter}.
  */
+public class PbfImporterTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class PbfImporterTest {
     private static void checkUserNull(OsmPrimitive osm, boolean hasToBeNull) {
         User usr = osm.getUser();
         if (hasToBeNull) {
             assertNull(osm + " -> " + usr, usr);
+            assertNull(usr, osm + " -> " + usr);
         } else {
             assertNotNull(osm + " -> " + usr, usr);
+            assertNotNull(usr, osm + " -> " + usr);
+        }
+    }
 …
      */
     @Test
     public void testParseDataSet() throws Exception {
+    void testParseDataSet() throws Exception {
         doTestMonaco(TestUtils.getTestDataRoot() + "/monaco-latest.osm.pbf", false);
+    }
 …
      */
     @Test
     public void testTicket10132() throws Exception {
+    void testTicket10132() throws Exception {
         doTestMonaco(TestUtils.getRegressionDataFile(10132, "Monaco-SP.osm.pbf"), true);
+    }
 …
      */
     @Test
     public void testTicket12567() throws Exception {
+    void testTicket12567() throws Exception {
         DataSet ds = new PbfImporter().parseDataSet(TestUtils.getRegressionDataFile(12567, "12390008.osm.pbf"));
         assertNotNull(ds);
 …
      */
     @Test
     public void testTicket14545() throws Exception {
+    void testTicket14545() throws Exception {
         DataSet ds = new PbfImporter().parseDataSet(TestUtils.getRegressionDataFile(14545, "reg14545.osm.pbf"));
         assertNotNull(ds);

applications/editors/josm/plugins/pdfimport/test/unit/org/openstreetmap/josm/plugins/pdfimport/pdfbox/PDFParserTest.java

-              r34609
+              r36064
 package org.openstreetmap.josm.plugins.pdfimport.pdfbox;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.awt.Rectangle;
 import java.io.File;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
 import org.openstreetmap.josm.plugins.pdfimport.PathOptimizer;
 public class PDFParserTest {
+class PDFParserTest {
     private PathOptimizer parse(String fileName) throws Exception {
 …
     @Test
     public void testParse9053() throws Exception {
+    void testParse9053() throws Exception {
         PathOptimizer data = parse(TestUtils.getRegressionDataFile(9053, "testpdf.pdf"));
         assertEquals(0, data.bounds.getMinX(), 0);
 …
     @Test
     public void testParse12176() throws Exception {
+    void testParse12176() throws Exception {
         PathOptimizer data = parse(TestUtils.getRegressionDataFile(12176, "LYD_Etage_0.pdf"));
         assertEquals(new Rectangle(595, 842), data.bounds);

applications/editors/josm/plugins/poly/test/unit/poly/PolyExporterTest.java

-              r34966
+              r36064
 package poly;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
 …
  * @author Gerd Petermann
  */
+public class PolyExporterTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences().timeout(20000);
+@BasicPreferences
+@Timeout(20)
+class PolyExporterTest {
     /**
      * Import file, export it, import the exported file and compare content
 …
      */
     @Test
     public void testSimpleExport() throws Exception {
+    void testSimpleExport() throws Exception {
         DataSet dsIn1 = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/simple.poly");
         assertNotNull(dsIn1);
 …
      */
     @Test
     public void testExport() throws Exception {
+    void testExport() throws Exception {
         DataSet dsIn1 = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/holes.poly");
         assertNotNull(dsIn1);

applications/editors/josm/plugins/poly/test/unit/poly/PolyImporterTest.java

-              r34860
+              r36064
 package poly;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.io.IllegalDataException;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
 …
  * @author Gerd Petermann
  */
+public class PolyImporterTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class PolyImporterTest {
     /**
      * @throws Exception if an error occurs
      */
     @Test
     public void testSimple() throws Exception {
+    void testSimple() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/simple.poly");
         assertNotNull(ds);
 …
      */
     @Test
     public void testSimple2() throws Exception {
+    void testSimple2() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/splitter.poly");
         assertNotNull(ds);
 …
      */
     @Test
     public void testHoles() throws Exception {
+    void testHoles() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/holes.poly");
         assertNotNull(ds);
 …
      */
     @Test
     public void testTwoOuter() throws Exception {
+    void testTwoOuter() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/australia_v.poly");
         assertNotNull(ds);
 …
      */
     @Test
     public void testDoubleEnd() throws Exception {
+    void testDoubleEnd() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/bremen-double-end.poly");
         assertNotNull(ds);
 …
      */
     @Test
     public void testMultipleFile() throws Exception {
+    void testMultipleFile() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/multi-concat.poly");
         assertNotNull(ds);
 …
     /**
      * Should throw an IllegalDataException
-     * @throws Exception if an error occurs
      */
     @Test (expected = IllegalDataException.class)
     public void testNameMissing() throws Exception {
         DataSet ds = new PolyImporter().parseDataSet(TestUtils.getTestDataRoot() + "/name-missing.poly");
         assertNull(ds);
+    @Test
+    void testNameMissing() {
+        final PolyImporter importer = new PolyImporter();
+        assertThrows(IllegalDataException.class, () -> importer.parseDataSet(TestUtils.getTestDataRoot() + "/name-missing.poly"));
+    }

applications/editors/josm/plugins/print/test/unit/org/openstreetmap/josm/plugins/print/PrintDialogTest.java

-              r33118
+              r36064
 package org.openstreetmap.josm.plugins.print;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.Arrays;
 …
 import javax.print.attribute.standard.OrientationRequested;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit test of {@link PrintDialog} class.
  */
+public class PrintDialogTest {
+    /**
+     * Setup test.
+     */
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class PrintDialogTest {
     /**
      * Unit test of {@link PrintDialog#unmarshallPrintSetting}
 …
      */
     @Test
     public void testUnmarshallPrintSetting() throws ReflectiveOperationException {
+    void testUnmarshallPrintSetting() throws ReflectiveOperationException {
         assertEquals(OrientationRequested.PORTRAIT, PrintDialog.unmarshallPrintSetting(Arrays.asList(
                 "javax.print.attribute.standard.OrientationRequested",
 …
      */
     @Test
     @Ignore("not fixed yet")
     public void testTicket13302() throws ReflectiveOperationException {
+    @Disabled("not fixed yet")
+    void testTicket13302() throws ReflectiveOperationException {
         assertEquals(OrientationRequested.PORTRAIT, PrintDialog.unmarshallPrintSetting(Arrays.asList(
                 "javax.print.attribute.standard.MediaSizeName",

applications/editors/josm/plugins/surveyor/test/unit/org/openstreetmap/josm/plugins/surveyor/SurveyorShowActionTest.java

-              r35262
+              r36064
 package org.openstreetmap.josm.plugins.surveyor;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 import org.openstreetmap.josm.tools.Logging;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 /**
  * Unit tests of {@link #SurveyorShowAction}
  */
+public class SurveyorShowActionTest {
+    /**
+     * Setup rule
+     */
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules().preferences();
+@BasicPreferences
+class SurveyorShowActionTest {
     @Test
     public void testCreateComponent() {
+    void testCreateComponent() {
         Logging.clearLastErrorAndWarnings();
         SurveyorComponent comp = SurveyorShowAction.createComponent();
         assertNotNull(comp);
         List<String> errors = Logging.getLastErrorAndWarnings();
         assertTrue(errors.toString(), errors.isEmpty());
+        assertTrue(errors.isEmpty(), errors.toString());
+    }
+}

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/AllUnitTests.java

-              r32519
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 import org.openstreetmap.josm.plugins.turnrestrictions.editor.AllEditorTests;
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
+@Suite
+@SelectClasses({
     AllEditorTests.class,
     TurnRestrictionBuilderTest.class

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.openstreetmap.josm.plugins.turnrestrictions.TurnRestrictionBuilder.intersectionAngle;
 import static org.openstreetmap.josm.plugins.turnrestrictions.TurnRestrictionBuilder.selectToWayAfterSplit;
 …
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.Node;
 …
 import org.openstreetmap.josm.plugins.turnrestrictions.TurnRestrictionBuilder.RelativeWayJoinOrientation;
 import org.openstreetmap.josm.plugins.turnrestrictions.editor.TurnRestrictionType;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+public class TurnRestrictionBuilderTest {
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+@BasicPreferences
+class TurnRestrictionBuilderTest {
     TurnRestrictionBuilder builder = new TurnRestrictionBuilder();
     boolean hasExactlyOneMemberWithRole(Relation r, final String role) {
         return r.getMembers().stream().filter(rm -> role.equals(rm.getRole())).findFirst().isPresent();
+        return r.getMembers().stream().anyMatch(rm -> role.equals(rm.getRole()));
+    }
     OsmPrimitive memberWithRole(Relation r, final String role) {
         Optional<RelationMember> opt = r.getMembers().stream().filter(rm -> role.equals(rm.getRole())).findFirst();
+        if (!opt.isPresent())
+            return null;
+        return opt.get().getMember();
+        return opt.map(RelationMember::getMember).orElse(null);
+    }
 …
      */
     @Test
     public void noUTurn_1() {
+    void testNoUTurn1() {
         Way w = new Way(1);
         Node n1 = new Node(1);
 …
     */
    @Test
    public void noUTurn_2() {
+   void testNoUTurn2() {
        Way w = new Way(1);
        Node n1 = new Node(1);
 …
    @Test
    public void nullSelection() {
+   void testNullSelection() {
        assertEmptyTurnRestriction(builder.build(null));
+   }
    @Test
    public void emptySelection() {
+   void testEmptySelection() {
        assertEmptyTurnRestriction(builder.build(new ArrayList<>()));
+   }
 …
     */
    @Test
    public void oneSelectedWay() {
+   void testOneSelectedWay() {
        Way w = new Way(1);
        Relation tr = builder.build(Arrays.asList(w));
+       Relation tr = builder.build(Collections.singletonList(w));
        assertNotNull(tr);
        assertEquals("restriction", tr.get("type"));
 …
     */
    @Test
    public void twoUnconnectedWays() {
+   void testTwoUnconnectedWays() {
        Way w1 = new Way(1);
        w1.setNodes(Arrays.asList(new Node(11), new Node(12)));
 …
     */
    @Test
    public void twoConnectedWays_1() {
+   void testTwoConnectedWays1() {
        Node n1 = new Node(1);
        n1.setCoor(new LatLon(1, 1));
 …
     */
    @Test
    public void twoConnectedWays_2() {
+   void testTwoConnectedWays2() {
        Node n1 = new Node(1);
        n1.setCoor(new LatLon(5, 5));
 …
    /**
+   * Two connected ways. end node of the first way connects to end node of
+   * the second way. left turn.
+   *
+   *
+   *           (7,5) -
+   *             ^     -    w2
+   *             | w1     ------> (6,7)
+   *             |
+   *           (5,5)
+   */
+  @Test
+  public void twoConnectedWays_3() {
+      Node n1 = new Node(1);
+      n1.setCoor(new LatLon(5, 5));
+      Node n2 = new Node(2);
+      n2.setCoor(new LatLon(7, 5));
+      Node n3 = new Node(3);
+      n3.setCoor(new LatLon(6, 7));
+      Way w1 = new Way(1);
+      w1.setNodes(Arrays.asList(n1, n2));
+      Way w2 = new Way(2);
+      w2.setNodes(Arrays.asList(n2, n3));
+      Relation tr = builder.build(Arrays.asList(w1, w2, n2));
+      assertNotNull(tr);
+      assertEquals("restriction", tr.get("type"));
+      assertEquals(3, tr.getMembersCount());
+      assertEquals(w1, memberWithRole(tr, "from"));
+      assertEquals(w2, memberWithRole(tr, "to"));
+      assertEquals(n2, memberWithRole(tr, "via"));
+      assertEquals("no_right_turn", tr.get("restriction"));
+  }
+  /**
+  * Two connected ways. end node of the first way connects to end node of
+  * the second way. left turn.
+  *
+  *
+  *           (10,10)
+  *                 \
+  *                  \
+  *                   \
+  *                    v
+  *                     (8,15)
+  *                    /
+  *                   /
+  *                  /
+  *                 v
+  *            (5,11)
+  */
+ @Test
+ public void twoConnectedWays_4() {
+     Node n1 = new Node(1);
+     n1.setCoor(new LatLon(10, 10));
+     Node n2 = new Node(2);
+     n2.setCoor(new LatLon(8, 15));
+     Node n3 = new Node(3);
+     n3.setCoor(new LatLon(5, 11));
+     Way w1 = new Way(1);
+     w1.setNodes(Arrays.asList(n1, n2));
+     Way w2 = new Way(2);
+     w2.setNodes(Arrays.asList(n2, n3));
+     Relation tr = builder.build(Arrays.asList(w1, w2, n2));
+     assertNotNull(tr);
+     assertEquals("restriction", tr.get("type"));
+     assertEquals(3, tr.getMembersCount());
+     assertEquals(w1, memberWithRole(tr, "from"));
+     assertEquals(w2, memberWithRole(tr, "to"));
+     assertEquals(n2, memberWithRole(tr, "via"));
+     assertEquals("no_right_turn", tr.get("restriction"));
+     /*
+      * opposite order, from w2 to w1. In  this case we have left turn.
+      */
+     tr = builder.build(Arrays.asList(w2, w1, n2));
+     assertNotNull(tr);
+     assertEquals("restriction", tr.get("type"));
+     assertEquals(3, tr.getMembersCount());
+     assertEquals(w2, memberWithRole(tr, "from"));
+     assertEquals(w1, memberWithRole(tr, "to"));
+     assertEquals(n2, memberWithRole(tr, "via"));
+     assertEquals("no_left_turn", tr.get("restriction"));
+    * Two connected ways. end node of the first way connects to end node of
+    * the second way. left turn.
+    *
+    *           (7,5) -
+    *             ^     -    w2
+    *             | w1     ------> (6,7)
+    *             |
+    *           (5,5)
+    */
+    @Test
+    void testTwoConnectedWays3() {
+        Node n1 = new Node(1);
+        n1.setCoor(new LatLon(5, 5));
+        Node n2 = new Node(2);
+        n2.setCoor(new LatLon(7, 5));
+        Node n3 = new Node(3);
+        n3.setCoor(new LatLon(6, 7));
+        Way w1 = new Way(1);
+        w1.setNodes(Arrays.asList(n1, n2));
+        Way w2 = new Way(2);
+        w2.setNodes(Arrays.asList(n2, n3));
+        Relation tr = builder.build(Arrays.asList(w1, w2, n2));
+        assertNotNull(tr);
+        assertEquals("restriction", tr.get("type"));
+        assertEquals(3, tr.getMembersCount());
+        assertEquals(w1, memberWithRole(tr, "from"));
+        assertEquals(w2, memberWithRole(tr, "to"));
+        assertEquals(n2, memberWithRole(tr, "via"));
+        assertEquals("no_right_turn", tr.get("restriction"));
+    }
+    /**
+     * Two connected ways. end node of the first way connects to end node of
+     * the second way. left turn.
+     *
+     *           (10,10)
+     *                 \
+     *                  \
+     *                   \
+     *                    v
+     *                     (8,15)
+     *                    /
+     *                   /
+     *                  /
+     *                 v
+     *            (5,11)
+     */
+    @Test
+    void testTwoConnectedWays4() {
+        Node n1 = new Node(1);
+        n1.setCoor(new LatLon(10, 10));
+        Node n2 = new Node(2);
+        n2.setCoor(new LatLon(8, 15));
+        Node n3 = new Node(3);
+        n3.setCoor(new LatLon(5, 11));
+        Way w1 = new Way(1);
+        w1.setNodes(Arrays.asList(n1, n2));
+        Way w2 = new Way(2);
+        w2.setNodes(Arrays.asList(n2, n3));
+        Relation tr = builder.build(Arrays.asList(w1, w2, n2));
+        assertNotNull(tr);
+        assertEquals("restriction", tr.get("type"));
+        assertEquals(3, tr.getMembersCount());
+        assertEquals(w1, memberWithRole(tr, "from"));
+        assertEquals(w2, memberWithRole(tr, "to"));
+        assertEquals(n2, memberWithRole(tr, "via"));
+        assertEquals("no_right_turn", tr.get("restriction"));
+        /*
+         * opposite order, from w2 to w1. In  this case we have left turn.
+         */
+        tr = builder.build(Arrays.asList(w2, w1, n2));
+        assertNotNull(tr);
+        assertEquals("restriction", tr.get("type"));
+        assertEquals(3, tr.getMembersCount());
+        assertEquals(w2, memberWithRole(tr, "from"));
+        assertEquals(w1, memberWithRole(tr, "to"));
+        assertEquals(n2, memberWithRole(tr, "via"));
+        assertEquals("no_left_turn", tr.get("restriction"));
+    }
 …
       */
      @Test
      public void intersectionAngle_1() {
+     void testIntersectionAngle1() {
          Node n1 = nn(1, 5, 5);
          Node n2 = nn(2, 5, 10);
 …
      */
     @Test
     public void intersectionAngle_2() {
+    void testIntersectionAngle2() {
         Node n1 = nn(1, 5, 5);
         Node n2 = nn(2, 5, 10);
 …
      *          /
      *      (-5, -10) n2
+    *           ^
+    *           |
+    *           | from
+    *           |
+    *       (-10,-10) n1
+    */
+   @Test
+   public void intersectionAngle_3() {
+       Node n1 = nn(1, -10, -10);
+       Node n2 = nn(2, -5, -10);
+       Node n3 = nn(3, -1, -6);
+       Way from = nw(1, n1, n2);
+       Way to = nw(2, n2, n3);
+       double a = TurnRestrictionBuilder.intersectionAngle(from, to);
+       assertEquals(45, Math.toDegrees(a), 1e-7);
+       /*
+        * if reversed from, the intersection angle is still 45
+        */
+       from = nw(1, n2, n1);
+       to = nw(2, n2, n3);
+       a = TurnRestrictionBuilder.intersectionAngle(from, to);
+       assertEquals(45, Math.toDegrees(a), 1e-7);
+       /*
+       * if reversed to, the intersection angle is still 45
+       */
+       from = nw(1, n1, n2);
+       to = nw(2, n3, n2);
+       a = TurnRestrictionBuilder.intersectionAngle(from, to);
+       assertEquals(45, Math.toDegrees(a), 1e-7);
+       /*
+       * if reversed both, the intersection angle is still 45
+       */
+       from = nw(1, n2, n1);
+       to = nw(2, n3, n2);
+       a = TurnRestrictionBuilder.intersectionAngle(from, to);
+       assertEquals(45, Math.toDegrees(a), 1e-7);
+   }
+   /**
+   *
+   *
+   *         (-1,-14) (n3)
+   *            ^
+   *            \
+   *             \ to
+   *              \
+   *          (-5, -10) n2
+  *               ^
+  *               |
+  *               | from
+  *               |
+  *           (-10,-10) n1
+  */
+ @Test
+ public void intersectionAngle_4() {
+     Node n1 = nn(1, -10, -10);
+     Node n2 = nn(2, -5, -10);
+     Node n3 = nn(3, -1, -14);
+     Way from = nw(1, n1, n2);
+     Way to = nw(2, n2, n3);
+     double a = TurnRestrictionBuilder.intersectionAngle(from, to);
+     assertEquals(-45, Math.toDegrees(a), 1e-7);
+     /*
+      * if reversed from, the intersection angle is still -45
+      */
+     from = nw(1, n2, n1);
+     to = nw(2, n2, n3);
+     a = TurnRestrictionBuilder.intersectionAngle(from, to);
+     assertEquals(-45, Math.toDegrees(a), 1e-7);
+     /*
+     * if reversed to, the intersection angle is still -45
+     *           ^
+     *           |
+     *           | from
+     *           |
+     *       (-10,-10) n1
      */
+     from = nw(1, n1, n2);
+     to = nw(2, n3, n2);
+     a = TurnRestrictionBuilder.intersectionAngle(from, to);
+     assertEquals(-45, Math.toDegrees(a), 1e-7);
+     /*
+     * if reversed both, the intersection angle is still 45
+    @Test
+    void testIntersectionAngle3() {
+        Node n1 = nn(1, -10, -10);
+        Node n2 = nn(2, -5, -10);
+        Node n3 = nn(3, -1, -6);
+        Way from = nw(1, n1, n2);
+        Way to = nw(2, n2, n3);
+        double a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(45, Math.toDegrees(a), 1e-7);
+        /*
+         * if reversed from, the intersection angle is still 45
+         */
+        from = nw(1, n2, n1);
+        to = nw(2, n2, n3);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(45, Math.toDegrees(a), 1e-7);
+        /*
+        * if reversed to, the intersection angle is still 45
+        */
+        from = nw(1, n1, n2);
+        to = nw(2, n3, n2);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(45, Math.toDegrees(a), 1e-7);
+        /*
+        * if reversed both, the intersection angle is still 45
+        */
+        from = nw(1, n2, n1);
+        to = nw(2, n3, n2);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(45, Math.toDegrees(a), 1e-7);
+    }
+    /**
+     *
+     *
+     *         (-1,-14) (n3)
+     *            ^
+     *            \
+     *             \ to
+     *              \
+     *          (-5, -10) n2
+     *               ^
+     *               |
+     *               | from
+     *               |
+     *           (-10,-10) n1
      */
+     from = nw(1, n2, n1);
+     to = nw(2, n3, n2);
+     a = TurnRestrictionBuilder.intersectionAngle(from, to);
+     assertEquals(-45, Math.toDegrees(a), 1e-7);
+ }
+     /*
+    @Test
+    void testIntersectionAngle4() {
+        Node n1 = nn(1, -10, -10);
+        Node n2 = nn(2, -5, -10);
+        Node n3 = nn(3, -1, -14);
+        Way from = nw(1, n1, n2);
+        Way to = nw(2, n2, n3);
+        double a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(-45, Math.toDegrees(a), 1e-7);
+        /*
+         * if reversed from, the intersection angle is still -45
+         */
+        from = nw(1, n2, n1);
+        to = nw(2, n2, n3);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(-45, Math.toDegrees(a), 1e-7);
+        /*
+        * if reversed to, the intersection angle is still -45
+        */
+        from = nw(1, n1, n2);
+        to = nw(2, n3, n2);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(-45, Math.toDegrees(a), 1e-7);
+        /*
+        * if reversed both, the intersection angle is still 45
+        */
+        from = nw(1, n2, n1);
+        to = nw(2, n3, n2);
+        a = TurnRestrictionBuilder.intersectionAngle(from, to);
+        assertEquals(-45, Math.toDegrees(a), 1e-7);
+    }
+    /**
+     *
      *      n21        w21        n22       w22            n23
 …
      */
     @Test
     public void splitToWay() {
+    void testSplitToWay() {
         Node n11 = new Node(11);
         n11.setCoor(new LatLon(5, 15));

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/AllEditorTests.java

-              r32519
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
 import junit.framework.TestCase;
+import org.junit.platform.suite.api.Suite;
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
+@Suite
+@SelectClasses({
     JosmSelectionListModelTest.class,
     TurnRestrictionEditorModelUnitTest.class,

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/BasicEditorPanelTest.java

-              r32519
+              r36064
 import javax.swing.JFrame;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
+ *
  */
 @Ignore("no test")
+@Disabled("no test")
 public class BasicEditorPanelTest extends JFrame {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/ExceptValueModelTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 public class ExceptValueModelTest {
+class ExceptValueModelTest {
+    @Test
+    public void testConstructors() {
+        new ExceptValueModel();
+        new ExceptValueModel(null);
+        new ExceptValueModel("");
+        new ExceptValueModel("  ");
+        new ExceptValueModel("hgv");
+        new ExceptValueModel("hgv;psv");
+        new ExceptValueModel("non_standard");
+    @ParameterizedTest
+    @ValueSource(strings = {"", "  ", "hgv", "hgv;psv", "non_standard"})
+    void testStringConstructors(String value) {
+        assertDoesNotThrow(() -> new ExceptValueModel(value));
+    }
     @Test
+    public void testSetValue() {
+    void testAdditionalConstructors() {
+        assertAll(() -> assertDoesNotThrow(() -> new ExceptValueModel()),
+                () -> assertDoesNotThrow(() -> new ExceptValueModel(null)));
+    }
+    @Test
+    void testSetValue() {
         ExceptValueModel evm;

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/JosmSelectionListModelTest.java

-              r33847
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.util.ArrayList;
 …
 import javax.swing.ListSelectionModel;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit test for {@see JosmSelctionListModel}
  */
+public class JosmSelectionListModelTest {
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class JosmSelectionListModelTest {
     @Test
+    public void testConstructor() {
+        assertNotNull(new JosmSelectionListModel(new OsmDataLayer(new DataSet(), "test", null)));
+    }
+    @Test(expected = IllegalArgumentException.class)
+    public void testConstructorNull() {
+        new JosmSelectionListModel(null);
+    void testConstructor() {
+        OsmDataLayer layer = new OsmDataLayer(new DataSet(), "test", null);
+        assertDoesNotThrow(() -> new JosmSelectionListModel(layer));
+    }
     @Test
+    public void test_setJOSMSelection() {
+    void testConstructorNull() {
+        assertThrows(IllegalArgumentException.class, () -> new JosmSelectionListModel(null));
+    }
+    @Test
+    void testSetJOSMSelection() {
         DataSet ds = new DataSet();
         OsmDataLayer layer = new OsmDataLayer(ds, "test", null);
 …
     @Test
     public void test_setJOSMSelection_withSelected() {
+    void testSetJOSMSelectionWithSelected() {
         DataSet ds = new DataSet();
         OsmDataLayer layer = new OsmDataLayer(ds, "test", null);
 …
     @Test
     public void test_getSelected() {
+    void testGetSelected() {
         DataSet ds = new DataSet();
         OsmDataLayer layer = new OsmDataLayer(ds, "test", null);
 …
     @Test
     public void test_setSelected() {
+    void testSetSelected() {
         // set selected with null is OK - nothing selected thereafter
         JosmSelectionListModel model = new JosmSelectionListModel(new OsmDataLayer(new DataSet(), "test", null));
 …
         List<OsmPrimitive> objects = (Arrays.asList(new Node(new LatLon(1, 1)), new Way(), new Relation()));
         model.setJOSMSelection(objects);
         model.setSelected(Arrays.asList(objects.get(0)));
+        model.setSelected(Collections.singletonList(objects.get(0)));
         assertEquals(Collections.singleton(objects.get(0)), model.getSelected());
         // select an object not-existing in the list of displayed objects
         model.setJOSMSelection(objects);
         model.setSelected(Arrays.asList(new Way()));
+        model.setSelected(Collections.singletonList(new Way()));
         assertTrue(model.getSelected().isEmpty());
+    }
     @Test
     public void test_editLayerChanged() {
+    void testEditLayerChanged() {
         DataSet ds = new DataSet();
         List<OsmPrimitive> objects = (Arrays.asList(new Node(new LatLon(1, 1)), new Way(), new Relation()));
         objects.stream().forEach(ds::addPrimitive);
+        objects.forEach(ds::addPrimitive);
         OsmDataLayer layer1 = new OsmDataLayer(ds, "layer1", null);

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionComboBoxTest.java

-              r32519
+              r36064
 import javax.swing.JFrame;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
+ *
  */
 @Ignore("no test")
+@Disabled("no test")
 public class TurnRestrictionComboBoxTest extends JFrame {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionEditorModelUnitTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+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.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.openstreetmap.josm.plugins.turnrestrictions.editor.TurnRestrictionLegRole.FROM;
 import static org.openstreetmap.josm.plugins.turnrestrictions.editor.TurnRestrictionLegRole.TO;
 …
 import java.util.Collections;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.PrimitiveId;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
 …
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * This is a unit test for {@link TurnRestrictionEditorModel}
  */
+public class TurnRestrictionEditorModelUnitTest {
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class TurnRestrictionEditorModelUnitTest {
     private final NavigationControler navigationControlerMock = new NavigationControler() {
 …
+    }
     @Before
+    @BeforeEach
     public void setUp() {
         ds = new DataSet();
 …
      * Test the constructor
      */
     @Test(expected = IllegalArgumentException.class)
     public void testConstructor1() {
         new TurnRestrictionEditorModel(null, navigationControlerMock);
+    @Test
+    void testConstructor1() {
+        assertThrows(IllegalArgumentException.class, () -> new TurnRestrictionEditorModel(null, navigationControlerMock));
+    }
 …
      * Test the constructor
      */
     @Test(expected = IllegalArgumentException.class)
     public void testConstructor2() {
         new TurnRestrictionEditorModel(layer, null);
+    }
     @Test
     public void testPopulateEmptyTurnRestriction() {
+    @Test
+    void testConstructor2() {
+        assertThrows(IllegalArgumentException.class, () -> new TurnRestrictionEditorModel(layer, null));
+    }
+    @Test
+    void testPopulateEmptyTurnRestriction() {
         // an "empty" turn restriction with a public id
         Relation r = new Relation(1);
 …
      */
     @Test
     public void test_populate_SimpleStandardTurnRestriction() {
+    void testPopulateSimpleStandardTurnRestriction() {
         buildDataSet1();
         model.populate(rel(1));
 …
         assertEquals(Collections.singleton(way(2)), model.getTurnRestrictionLeg(FROM));
         assertEquals(Collections.singleton(way(3)), model.getTurnRestrictionLeg(TO));
         assertEquals(Arrays.asList(node(22)), model.getVias());
+        assertEquals(Collections.singletonList(node(22)), model.getVias());
         assertEquals("no_left_turn", model.getRestrictionTagValue());
         assertEquals("", model.getExcept().getValue());
 …
     @Test
     public void setFrom() {
+    void testSetFrom() {
         buildDataSet1();
         model.populate(rel(1));
 …
         // set another way as from
         model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, way(4).getPrimitiveId());
         assertEquals(Collections.singleton(way(4)), model.getTurnRestrictionLeg(TurnRestrictionLegRole.FROM));
+        assertEquals(Collections.singleton(way(4)), model.getTurnRestrictionLeg(FROM));
         // delete the/all members with role 'from'
         model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, null);
+        assertTrue(model.getTurnRestrictionLeg(TurnRestrictionLegRole.FROM).isEmpty());
+        try {
+            // can't add a node as 'from'
+            model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, node(21).getPrimitiveId());
+            fail();
+        } catch (IllegalArgumentException e) {
+            // OK
+            System.out.println(e.getMessage());
+        }
+        try {
+            // can't set a way as 'from' if it isn't part of the dataset
+            model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, new Way().getPrimitiveId());
+            fail();
+        } catch (IllegalStateException e) {
+            // OK
+            System.out.println(e.getMessage());
+        }
+    }
+    @Test
+    public void setTo() {
+        assertTrue(model.getTurnRestrictionLeg(FROM).isEmpty());
+        // can't add a node as 'from'
+        PrimitiveId node = node(21).getPrimitiveId();
+        assertThrows(IllegalArgumentException.class,
+                () -> model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, node));
+        // can't set a way as 'from' if it isn't part of the dataset
+        PrimitiveId way = new Way().getPrimitiveId();
+        assertThrows(IllegalStateException.class, () -> model.setTurnRestrictionLeg(TurnRestrictionLegRole.FROM, way));
+    }
+    @Test
+    void setTo() {
         buildDataSet1();
         model.populate(rel(1));
 …
         // set another way as from
         model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, way(4).getPrimitiveId());
         assertEquals(Collections.singleton(way(4)), model.getTurnRestrictionLeg(TurnRestrictionLegRole.TO));
+        assertEquals(Collections.singleton(way(4)), model.getTurnRestrictionLeg(TO));
         // delete the/all members with role 'from'
         model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, null);
+        assertTrue(model.getTurnRestrictionLeg(TurnRestrictionLegRole.TO).isEmpty());
+        try {
+            // can't add a node as 'from'
+            model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, node(21).getPrimitiveId());
+            fail();
+        } catch (IllegalArgumentException e) {
+            // OK
+            System.out.println(e.getMessage());
+        }
+        try {
+            // can't set a way as 'from' if it isn't part of the dataset
+            model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, new Way().getPrimitiveId());
+            fail();
+        } catch (IllegalStateException e) {
+            // OK
+            System.out.println(e.getMessage());
+        }
+        assertTrue(model.getTurnRestrictionLeg(TO).isEmpty());
+        PrimitiveId node = node(21).getPrimitiveId();
+        assertThrows(IllegalArgumentException.class, () -> model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, node));
+        PrimitiveId way = new Way().getPrimitiveId();
+        assertThrows(IllegalStateException.class, () -> model.setTurnRestrictionLeg(TurnRestrictionLegRole.TO, way));
+    }
 …
         // one node as via - OK
         model.setVias(Arrays.asList(node(22)));
         assertEquals(Arrays.asList(node(22)), model.getVias());
+        model.setVias(Collections.singletonList(node(22)));
+        assertEquals(Collections.singletonList(node(22)), model.getVias());
         // pass in null as vias -> remove all vias
 …
         // null values in the list of vias are skipped
         model.setVias(Arrays.asList(null, node(22)));
         assertEquals(Arrays.asList(node(22)), model.getVias());
+        assertEquals(Collections.singletonList(node(22)), model.getVias());
         try {
             // an object which doesn't belong to the same dataset can't be a via
             model.setVias(Arrays.asList(new Node(LatLon.ZERO)));
+            model.setVias(Collections.singletonList(new Node(LatLon.ZERO)));
             fail();
         } catch (IllegalArgumentException e) {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionEditorTest.java

-              r32519
+              r36064
 import javax.swing.JFrame;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
+ *
  */
 @Ignore("no test")
+@Disabled("no test")
 public class TurnRestrictionEditorTest extends JFrame {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionLegEditorTest.java

-              r34148
+              r36064
 import javax.swing.JScrollPane;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
  * {@see TurnRestrictionLegEditor}
  */
 @Ignore("no test")
+@Disabled("no test")
 public class TurnRestrictionLegEditorTest extends JFrame {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionLegEditorUnitTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
-import static org.junit.Assert.assertEquals;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 /**
  * Unit test for the {@link TurnRestrictionLegEditor}
  */
+public class TurnRestrictionLegEditorUnitTest {
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class TurnRestrictionLegEditorUnitTest {
     private DataSet ds;
     private OsmDataLayer layer;
     private TurnRestrictionEditorModel model;
     @Before
+    @BeforeEach
     public void setUp() {
         ds = new DataSet();
 …
     @Test
     public void testConstructor1() {
+    void testConstructor1() {
         TurnRestrictionLegEditor editor = new TurnRestrictionLegEditor(model, TurnRestrictionLegRole.FROM);
         assertEquals(model, editor.getModel());
 …
+    }
     @Test(expected = IllegalArgumentException.class)
     public void testConstructor2() {
         new TurnRestrictionLegEditor(null, TurnRestrictionLegRole.FROM);
+    @Test
+    void testConstructor2() {
+        assertThrows(IllegalArgumentException.class, () -> new TurnRestrictionLegEditor(null, TurnRestrictionLegRole.FROM));
+    }
     @Test(expected = IllegalArgumentException.class)
     public void testConstructor3() {
         new TurnRestrictionLegEditor(model, null);
+    @Test
+    void testConstructor3() {
+        assertThrows(IllegalArgumentException.class, () -> new TurnRestrictionLegEditor(model, null));
+    }
+}

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionTypeRendererTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import javax.swing.JLabel;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+public class TurnRestrictionTypeRendererTest {
+    @Rule
+    public JOSMTestRules rules = new JOSMTestRules().preferences();
+@BasicPreferences
+class TurnRestrictionTypeRendererTest {
     @Test
     public void test_Constructor() {
+    void testConstructor() {
         TurnRestrictionTypeRenderer renderer = new TurnRestrictionTypeRenderer();
 …
     @Test
     public void test_getListCellRendererComponent_1() {
+    void testGetListCellRendererComponent1() {
         TurnRestrictionTypeRenderer renderer = new TurnRestrictionTypeRenderer();

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionTypeTest.java

-              r32925
+              r36064
 package org.openstreetmap.josm.plugins.turnrestrictions.editor;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import org.junit.Test;
+import org.junit.jupiter.api.Test;
+public class TurnRestrictionTypeTest {
+class TurnRestrictionTypeTest {
     @Test
     public void test_fromTagValue() {
+    void testFromTagValue() {
         TurnRestrictionType type = TurnRestrictionType.fromTagValue("no_left_turn");

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/VehicleExceptionEditorTest.java

-              r32519
+              r36064
 import javax.swing.JFrame;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
+ *
  */
 @Ignore("no test")
+@Disabled("no test")
 public class VehicleExceptionEditorTest extends JFrame {
     TurnRestrictionEditorModel model;

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/editor/ViaListTest.java

-              r32519
+              r36064
 import javax.swing.JList;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.DataSet;
 …
+ *
  */
 @Ignore("no test")
+@Disabled("no test")
 public class ViaListTest extends JFrame {

applications/editors/josm/plugins/turnrestrictions/test/unit/org/openstreetmap/josm/plugins/turnrestrictions/qa/IssuesViewTest.java

-              r32519
+              r36064
 import javax.swing.JScrollPane;
 import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
  * Simple test application for layout and functionality of the issues view.
  */
 @Ignore("no test")
+@Disabled("no test")
 public class IssuesViewTest extends JFrame {
     private IssuesModel model;

Context Navigation

Changeset 36064 in osm for applications/editors/josm/plugins

Legend:

Download in other formats: