Ticket #16567: josm16567-junit5_assertions.patch

test/functional/org/openstreetmap/josm/io/MultiFetchServerObjectReaderTest.java

@@ -51 +51 @@
  * Unit tests of {@link MultiFetchServerObjectReader}.
  */
 @SuppressFBWarnings(value = "CRLF_INJECTION_LOGS")
-@Timeout(value = 60, unit = TimeUnit.SECONDS)
+@Timeout(value = 1, unit = TimeUnit.MINUTES)
 class MultiFetchServerObjectReaderTest {
     private static final Logger logger = Logger.getLogger(MultiFetchServerObjectReader.class.getName());
 

test/functional/org/openstreetmap/josm/tools/HttpClientTest.java

@@ -332 +332 @@
     }
 
     /**
-     * Test of {@link Response#uncompress} method with Gzip compression.
+     * Test of {@link Response#uncompress(boolean)} method with Gzip compression.
      * @throws IOException if any I/O error occurs
      */
     @Test
@@ -352 +352 @@
     }
 
     /**
-     * Test of {@link Response#uncompress} method with Bzip compression.
+     * Test of {@link Response#uncompress(boolean)} method with Bzip compression.
      * @throws IOException if any I/O error occurs
      */
     @Test
@@ -372 +372 @@
     }
 
     /**
-     * Test of {@link Response#uncompress} method with Bzip compression.
+     * Test of {@link Response#uncompress(boolean)} method with Bzip compression.
      * @throws IOException if any I/O error occurs
      */
     @Test

test/performance/org/openstreetmap/josm/data/osm/visitor/paint/AbstractMapRendererPerformanceTestParent.java

@@ -30 +30 @@
 /**
  * Abstract superclass of {@code StyledMapRendererPerformanceTest} and {@code WireframeMapRendererPerformanceTest}.
  */
-@Timeout(value = 15*60, unit = TimeUnit.SECONDS)
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
 abstract class AbstractMapRendererPerformanceTestParent {
 
     private static final int IMG_WIDTH = 1400;

test/performance/org/openstreetmap/josm/data/osm/KeyValuePerformanceTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.osm;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -28 +28 @@
  * This test measures the performance of {@link OsmPrimitive#get(String)} and related.
  * @author Michael Zangl
  */
-@Timeout(value = 15*60, unit = TimeUnit.SECONDS)
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
 class KeyValuePerformanceTest {
     private static final int PUT_RUNS = 10000;
     private static final int GET_RUNS = 100000;
@@ -95 +95 @@
 
         timer = PerformanceTestUtils.startTimer("str1.equals(str2) = fails (without intern)");
         for (int i = 0; i < STRING_INTERN_TESTS; i++) {
-            assertFalse(str1.equals(str2));
+            assertNotEquals(str1, str2);
         }
         timer.done();
 

test/performance/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSStyleSourceFilterTest.java

@@ -17 +17 @@
  * Tests how fast {@link MapCSSStyleSource} finds the right style candidates for one object.
  * @author Michael Zangl
  */
-@Timeout(value = 15*60, unit = TimeUnit.SECONDS)
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
 class MapCSSStyleSourceFilterTest {
 
     private static final int TEST_RULE_COUNT = 10000;
@@ -70 +70 @@
         }
 
         private void addRule(String selector) {
-            sb.append(selector + " {}\n");
+            sb.append(selector).append(" {}\n");
         }
 
         public String getCss() {

test/performance/org/openstreetmap/josm/gui/mappaint/MapRendererPerformanceTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui.mappaint;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
@@ -20 +22 @@
 
 import javax.imageio.ImageIO;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -124 +125 @@
         filterStyle = MapPaintStyles.addStyle(se);
         List<StyleSource> sources = MapPaintStyles.getStyles().getStyleSources();
         filterStyleIdx = sources.indexOf(filterStyle);
-        Assert.assertEquals(2, filterStyleIdx);
+        assertEquals(2, filterStyleIdx);
 
-        Assert.assertEquals(Feature.values().length, filterStyle.settings.size());
+        assertEquals(Feature.values().length, filterStyle.settings.size());
         for (StyleSetting set : filterStyle.settings) {
             BooleanStyleSetting bset = (BooleanStyleSetting) set;
             String prefKey = bset.getKey();
@@ -138 +139 @@
                     break;
                 }
             }
-            Assert.assertTrue(prefKey, found);
+            assertTrue(found, prefKey);
         }
 
         MapCSSStyleSource defaultStyle = null;
@@ -150 +151 @@
                 break;
             }
         }
-        Assert.assertNotNull(defaultStyle);
+        assertNotNull(defaultStyle);
 
         for (StyleSetting set : defaultStyle.settings) {
             if (set instanceof BooleanStyleSetting) {
@@ -160 +161 @@
                 }
             }
         }
-        Assert.assertNotNull(hideIconsSetting);
+        assertNotNull(hideIconsSetting);
         hideIconsSetting.setValue(false);
         MapPaintStyleLoader.reloadStyles(defaultStyleIdx);
 
@@ -208 +209 @@
             nc.zoomTo(ProjectionRegistry.getProjection().latlon2eastNorth(center), scale);
             if (checkScale) {
                 int lvl = Selector.GeneralSelector.scale2level(nc.getDist100Pixel());
-                Assert.assertEquals(17, lvl);
+                assertEquals(17, lvl);
             }
 
             if (bounds == null) {
@@ -359 +360 @@
         }
 
         public void dumpTimes() {
-            System.out.print(String.format("gen. %4d, sort %4d, draw %4d%n", getGenerateTime(), getSortTime(), getDrawTime()));
+            System.out.printf("gen. %4d, sort %4d, draw %4d%n", getGenerateTime(), getSortTime(), getDrawTime());
         }
 
         public void dumpElementCount() {

test/performance/org/openstreetmap/josm/io/OsmReaderPerformanceTest.java

@@ -26 +26 @@
  *
  * @author Michael Zangl
  */
-@Timeout(value = 15*60, unit = TimeUnit.SECONDS)
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
 class OsmReaderPerformanceTest {
     private static final int TIMES = 4;
 

test/performance/org/openstreetmap/josm/io/OsmWriterPerformanceTest.java

@@ -19 +19 @@
  * <p>
  * For this, we use the neubrandenburg-file, which is a good real world example of an OSM file.
  */
-@Timeout(value = 15*60, unit = TimeUnit.SECONDS)
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
 class OsmWriterPerformanceTest {
     private static final int TIMES = 4;
     private DataSet neubrandenburgDataSet;

test/unit/org/openstreetmap/josm/actions/corrector/ReverseWayTagCorrectorTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.actions.corrector;
 
+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 java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.data.correction.TagCorrection;
@@ -104 +107 @@
     }
 
     private void assertSwitch(Tag oldTag, Tag newTag) {
-        Assert.assertEquals(newTag, ReverseWayTagCorrector.TagSwitcher.apply(oldTag));
+        assertEquals(newTag, ReverseWayTagCorrector.TagSwitcher.apply(oldTag));
     }
 
     private Way buildWayWithMiddleNode(String middleNodeTags) {
@@ -127 +130 @@
     @Test
     void testSwitchingWayNodes() {
         final Map<OsmPrimitive, List<TagCorrection>> tagCorrections = getTagCorrectionsForWay("direction=forward");
-        Assert.assertEquals(1, tagCorrections.size());
-        Assert.assertEquals(Collections.singletonList(new TagCorrection("direction", "forward", "direction", "backward")),
+        assertEquals(1, tagCorrections.size());
+        assertEquals(Collections.singletonList(new TagCorrection("direction", "forward", "direction", "backward")),
                 tagCorrections.values().iterator().next());
     }
 
@@ -137 +140 @@
      */
     @Test
     void testNotSwitchingWayNodes() {
-        Assert.assertEquals(0, getTagCorrectionsForWay("direction=SSW").size());
-        Assert.assertEquals(0, getTagCorrectionsForWay("direction=145").size());
+        assertEquals(0, getTagCorrectionsForWay("direction=SSW").size());
+        assertEquals(0, getTagCorrectionsForWay("direction=145").size());
     }
 
     /**
@@ -147 +150 @@
     @Test
     void testIsReversible() {
         Way w0 = buildWayWithMiddleNode("highway=stop");
-        Assert.assertTrue(ReverseWayTagCorrector.isReversible(w0));
+        assertTrue(ReverseWayTagCorrector.isReversible(w0));
         Way w1 = buildWayWithMiddleNode("direction=forward");
-        Assert.assertFalse(ReverseWayTagCorrector.isReversible(w1));
-        Assert.assertEquals(3, w1.getNodesCount());
+        assertFalse(ReverseWayTagCorrector.isReversible(w1));
+        assertEquals(3, w1.getNodesCount());
         w1.getNodes().forEach(n -> n.setKeys(null));
-        Assert.assertTrue(ReverseWayTagCorrector.isReversible(w1));
+        assertTrue(ReverseWayTagCorrector.isReversible(w1));
         w1.put("oneway", "yes");
-        Assert.assertFalse(ReverseWayTagCorrector.isReversible(w1));
+        assertFalse(ReverseWayTagCorrector.isReversible(w1));
     }
 
 }

test/unit/org/openstreetmap/josm/actions/upload/FixDataHookTest.java

@@ -3 +3 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -98 +99 @@
         assertFalse(w2.hasKey("highway"));
         assertTrue(w2.hasKey("ford"));
 
-        assertFalse("false".equals(w3.get("oneway")));
-        assertTrue("no".equals(w3.get("oneway")));
+        assertNotEquals("false", w3.get("oneway"));
+        assertEquals("no", w3.get("oneway"));
 
-        assertFalse("0".equals(w4.get("oneway")));
-        assertTrue("no".equals(w4.get("oneway")));
+        assertNotEquals("0", w4.get("oneway"));
+        assertEquals("no", w4.get("oneway"));
 
-        assertFalse("true".equals(w5.get("oneway")));
-        assertTrue("yes".equals(w5.get("oneway")));
+        assertNotEquals("true", w5.get("oneway"));
+        assertEquals("yes", w5.get("oneway"));
 
-        assertFalse("1".equals(w6.get("oneway")));
-        assertTrue("yes".equals(w6.get("oneway")));
+        assertNotEquals("1", w6.get("oneway"));
+        assertEquals("yes", w6.get("oneway"));
 
         assertFalse(w7.hasKey("highway"));
         assertTrue(w7.hasKey("barrier"));
 
-        assertFalse("multipolygon".equals(r1.get("type")));
-        assertTrue("boundary".equals(r1.get("type")));
+        assertNotEquals("multipolygon", r1.get("type"));
+        assertEquals("boundary", r1.get("type"));
 
-        assertTrue("space_end".equals(r2.get("foo")));
-        assertTrue("space_begin".equals(r2.get("bar")));
-        assertTrue("space_both".equals(r2.get("baz")));
+        assertEquals("space_end", r2.get("foo"));
+        assertEquals("space_begin", r2.get("bar"));
+        assertEquals("space_both", r2.get("baz"));
         assertFalse(r2.hasKey(" space_begin"));
         assertFalse(r2.hasKey("space_end "));
         assertFalse(r2.hasKey(" space_both "));

test/unit/org/openstreetmap/josm/actions/SplitWayActionTest.java

@@ -6 +6 @@
 
 import java.util.Arrays;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
@@ -108 +107 @@
         SplitWayAction.runOn(dataSet);
         for (RelationMember member : restriction.getMembers()) {
             if ("from".equals(member.getRole())) {
-                Assert.assertTrue(member.getWay().containsNode(via));
+                assertTrue(member.getWay().containsNode(via));
             }
         }
     }

test/unit/org/openstreetmap/josm/command/AddPrimitivesCommandTest.java

@@ -114 +114 @@
         NodeData data2 = createTestNode(7);
 
         AddPrimitivesCommand command1 = new AddPrimitivesCommand(testData, ds);
-        AddPrimitivesCommand command2 = new AddPrimitivesCommand(Arrays.<PrimitiveData>asList(data2), ds);
+        AddPrimitivesCommand command2 = new AddPrimitivesCommand(Arrays.asList(data2), ds);
 
         assertEquals("Added 3 objects", command1.getDescriptionText());
         assertEquals("Added 1 object", command2.getDescriptionText());
@@ -341 +341 @@
         WayData way = new WayData(2);
         way.put("test", "test");
         way.setNodeIds(Arrays.asList(node1.getId(), node2.getId()));
-        List<PrimitiveData> testData = Arrays.<PrimitiveData>asList(node1, node2, way);
-        return testData;
+        return Arrays.asList(node1, node2, way);
     }
 
     private NodeData createTestNode(int id) {

test/unit/org/openstreetmap/josm/command/ChangeCommandTest.java

@@ -68 +68 @@
         new ChangeCommand(testData.existingNode, newNode).executeCommand();
 
         assertEquals("new", testData.existingNode.get("new"));
-        assertEquals(null, testData.existingNode.get("existing"));
+        assertNull(testData.existingNode.get("existing"));
         assertEquals(LatLon.NORTH_POLE, testData.existingNode.getCoor());
 
         Way newWay = new Way(10);

test/unit/org/openstreetmap/josm/data/gpx/GpxImageCorrelationTest.java

@@ -115 +115 @@
     @Test
     void testMatchGpxTrack1() {
         assertEquals(7, GpxImageCorrelation.matchGpxTrack(images, gpx, new GpxImageCorrelationSettings(0, false)));
-        assertEquals(null, ib.getPos());
+        assertNull(ib.getPos());
         assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos()); // start of track
         assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos()); // exact match
         assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos()); // exact match
@@ -132 +132 @@
                 && i4.hasNewGpsData() && i5.hasNewGpsData() && i6.hasNewGpsData());
         // First waypoint has no speed in matchGpxTrack(). Speed is calculated
         // and not taken from GPX track.
-        assertEquals(null, ib.getSpeed());
-        assertEquals(null, i0.getSpeed());
-        assertEquals(Double.valueOf(11.675317966018756), i1.getSpeed(), 0.000001);
-        assertEquals(Double.valueOf(24.992418392716967), i2.getSpeed(), 0.000001);
-        assertEquals(Double.valueOf(27.307968754679223), i3.getSpeed(), 0.000001);
-        assertEquals(null, ib.getElevation());
-        assertEquals(null, i0.getElevation());
-        assertEquals(Double.valueOf(489.29), i1.getElevation(), 0.000001);
-        assertEquals(Double.valueOf((490.40 + 489.75) / 2), i2.getElevation(), 0.000001);
-        assertEquals(Double.valueOf(486.368333333), i3.getElevation(), 0.000001);
+        assertNull(ib.getSpeed());
+        assertNull(i0.getSpeed());
+        assertEquals(11.675317966018756, i1.getSpeed(), 0.000001);
+        assertEquals(24.992418392716967, i2.getSpeed(), 0.000001);
+        assertEquals(27.307968754679223, i3.getSpeed(), 0.000001);
+        assertNull(ib.getElevation());
+        assertNull(i0.getElevation());
+        assertEquals(489.29, i1.getElevation(), 0.000001);
+        assertEquals((490.40 + 489.75) / 2, i2.getElevation(), 0.000001);
+        assertEquals(486.368333333, i3.getElevation(), 0.000001);
         // interpolated elevation between trackpoints with interpolated timestamps
-        assertEquals(Double.valueOf(475.393978719), i4.getElevation(), 0.000001);
-        assertEquals(null, i5.getElevation());
-        assertEquals(null, i6.getElevation());
+        assertEquals(475.393978719, i4.getElevation(), 0.000001);
+        assertNull(i5.getElevation());
+        assertNull(i6.getElevation());
 
-        assertEquals(null, ib.getGpsInstant());
+        assertNull(ib.getGpsInstant());
         assertEquals(DateUtils.parseInstant("2016:01:03 11:59:54"), i0.getGpsInstant()); // original time is kept
         assertEquals(DateUtils.parseInstant("2016:01:03 12:04:01"), i1.getGpsInstant());
         assertEquals(DateUtils.parseInstant("2016:01:03 12:04:57"), i2.getGpsInstant());
@@ -167 +167 @@
         s.putBoolean("geoimage.seg.int", false);
 
         assertEquals(4, GpxImageCorrelation.matchGpxTrack(images, gpx, new GpxImageCorrelationSettings(0, false)));
-        assertEquals(null, ib.getPos());
-        assertEquals(null, i0.getPos());
+        assertNull(ib.getPos());
+        assertNull(i0.getPos());
         assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
         assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2,
                 (8.792974585667253 + 8.792809881269932) / 2), i2.getPos());
         assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
         assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
-        assertEquals(null, i5.getPos());
-        assertEquals(null, i6.getPos());
+        assertNull(i5.getPos());
+        assertNull(i6.getPos());
     }
 
     /**
@@ -195 +195 @@
         s.putBoolean("geoimage.seg.int", false);
 
         assertEquals(6, GpxImageCorrelation.matchGpxTrack(images, gpx, new GpxImageCorrelationSettings(0, false)));
-        assertEquals(null, ib.getPos());
+        assertNull(ib.getPos());
         assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos());
         assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
         assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2,
@@ -203 +203 @@
         assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
         assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
         assertEquals(new CachedLatLon(47.19819249585271, 8.78536943346262), i5.getPos());
-        assertEquals(null, i6.getPos());
+        assertNull(i6.getPos());
         assertEquals(new CachedLatLon(1, 2), i7.getPos());
     }
 
@@ -227 +227 @@
         assertEquals(new CachedLatLon(47.198845306804905, 8.783144918860685), i5.getPos()); // interpolated between tracks
         assertEquals(new CachedLatLon(47.19985828931693, 8.77969308585768), i6.getPos()); // different values than in tests #1 and #3!
 
-        assertEquals(Double.valueOf(447.894014085), i5.getElevation(), 0.000001);
-        assertEquals(Double.valueOf(437.395070423), i6.getElevation(), 0.000001);
+        assertEquals(447.894014085, i5.getElevation(), 0.000001);
+        assertEquals(437.395070423, i6.getElevation(), 0.000001);
 
         assertEquals(new CachedLatLon(47.20126815140247, 8.77192972227931), i7.getPos());
     }
@@ -264 +264 @@
         assertEquals(new CachedLatLon(47.198845306804905, 8.783144918860685), i5.getPos());
         assertEquals(new CachedLatLon(47.19985828931693, 8.77969308585768), i6.getPos());
 
-        assertEquals(Double.valueOf(447.894014085), i5.getElevation(), 0.000001);
-        assertEquals(Double.valueOf(437.395070423), i6.getElevation(), 0.000001);
+        assertEquals(447.894014085, i5.getElevation(), 0.000001);
+        assertEquals(437.395070423, i6.getElevation(), 0.000001);
 
         assertEquals(new CachedLatLon(47.20126815140247, 8.77192972227931), i7.getPos());
     }

test/unit/org/openstreetmap/josm/data/osm/history/HistoryWayTest.java

@@ -79 +79 @@
         assertEquals(1, way.getNodeId(0));
         try {
             way.getNodeId(1);
-            fail("expected expection of type " + IndexOutOfBoundsException.class.toString());
+            fail("expected exception of type " + IndexOutOfBoundsException.class);
         } catch (IndexOutOfBoundsException e) {
             // OK
             Logging.trace(e);

test/unit/org/openstreetmap/josm/data/osm/search/SearchCompilerTest.java

@@ -18 +18 @@
 import java.util.Collections;
 import java.util.Set;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -753 +752 @@
     void testEqualsContract() {
         TestUtils.assumeWorkingEqualsVerifier();
         Set<Class<? extends Match>> matchers = TestUtils.getJosmSubtypes(Match.class);
-        Assert.assertTrue(matchers.size() >= 10); // if it finds less than 10 classes, something is broken
+        assertTrue(matchers.size() >= 10); // if it finds less than 10 classes, something is broken
         for (Class<?> c : matchers) {
             Logging.debug(c.toString());
             EqualsVerifier.forClass(c).usingGetClass()

test/unit/org/openstreetmap/josm/data/osm/ChangesetTest.java

@@ -5 +5 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.openstreetmap.josm.data.osm.Changeset.MAX_CHANGESET_TAG_LENGTH;
 
 import java.time.Duration;
@@ -15 +16 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.Bounds;
@@ -47 +47 @@
         // Cannot add null map => IllegalArgumentException
         try {
             cs.setKeys(null);
-            Assert.fail("Should have thrown an IllegalArgumentException as we gave a null argument.");
+            fail("Should have thrown an IllegalArgumentException as we gave a null argument.");
         } catch (IllegalArgumentException e) {
             Logging.trace(e);
             // Was expected
@@ -62 +62 @@
         keys.put("empty", null);
         keys.put("test", "test");
         cs.setKeys(keys);
-        Assert.assertEquals("Both valid keys should have been put in the ChangeSet.", 2, cs.getKeys().size());
+        assertEquals(2, cs.getKeys().size(), "Both valid keys should have been put in the ChangeSet.");
 
         // Add a map with too long values => IllegalArgumentException
         keys = new HashMap<>();
@@ -70 +70 @@
         keys.put("test", IntStream.range(0, MAX_CHANGESET_TAG_LENGTH + 1).mapToObj(i -> "x").collect(Collectors.joining()));
         try {
             cs.setKeys(keys);
-            Assert.fail("Should have thrown an IllegalArgumentException as we gave a too long value.");
+            fail("Should have thrown an IllegalArgumentException as we gave a too long value.");
         } catch (IllegalArgumentException e) {
             Logging.trace(e);
             // Was expected

test/unit/org/openstreetmap/josm/data/osm/DataSetMergerTest.java

@@ -1000 +1000 @@
 
         //-- merge it
         DataSetMerger visitor = new DataSetMerger(my, their);
-        assertThrows(DataIntegrityProblemException.class, () -> visitor.merge());
+        assertThrows(DataIntegrityProblemException.class, visitor::merge);
     }
 
     /**

test/unit/org/openstreetmap/josm/data/osm/DataSetTest.java

@@ -10 +10 @@
 import java.util.HashSet;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
@@ -42 +41 @@
     void testSearchRelations() {
         final DataSet ds = new DataSet();
         // null bbox => empty list
-        Assert.assertTrue(
-            "Empty data set should produce an empty list.",
-            ds.searchRelations(null).isEmpty()
-        );
+        assertTrue(ds.searchRelations(null).isEmpty(), "Empty data set should produce an empty list.");
 
         // empty data set, any bbox => empty list
         BBox bbox = new BBox(new LatLon(-180, -90), new LatLon(180, 90));
-        Assert.assertTrue(
-            "Empty data set should produce an empty list.",
-            ds.searchRelations(bbox).isEmpty()
-        );
+        assertTrue(ds.searchRelations(bbox).isEmpty(), "Empty data set should produce an empty list.");
 
         // data set with elements in the given bbox => these elements
         Node node = new Node(LatLon.ZERO);
@@ -63 +56 @@
         ds.addPrimitive(r);
         bbox = new BBox(new LatLon(-1.0, -1.0), new LatLon(1.0, 1.0));
         List<Relation> result = ds.searchRelations(bbox);
-        Assert.assertEquals("We should have found only one item.", 1, result.size());
-        Assert.assertTrue("The item found is relation r.", result.contains(r));
+        assertEquals(1, result.size(), "We should have found only one item.");
+        assertTrue(result.contains(r), "The item found is relation r.");
     }
 
     /**
@@ -74 +67 @@
     void testSearchPrimitives() {
         final DataSet ds = new DataSet();
         // null bbox => empty list
-        Assert.assertTrue("Empty data set should produce an empty list.", ds.searchPrimitives(null).isEmpty());
+        assertTrue(ds.searchPrimitives(null).isEmpty(), "Empty data set should produce an empty list.");
 
         // empty data set, any bbox => empty list
         BBox bbox = new BBox(new LatLon(-180, -90), new LatLon(180, 90));
-        Assert.assertTrue("Empty data set should produce an empty list.", ds.searchPrimitives(bbox).isEmpty());
+        assertTrue(ds.searchPrimitives(bbox).isEmpty(), "Empty data set should produce an empty list.");
         // data set with elements in the given bbox => these elements
         Node node = new Node(LatLon.ZERO);
         Node node2 = new Node(new LatLon(-0.01, -0.01));
@@ -91 +84 @@
         ds.addPrimitive(r);
         bbox = new BBox(new LatLon(-1.0, -1.0), new LatLon(1.0, 1.0));
         List<OsmPrimitive> result = ds.searchPrimitives(bbox);
-        Assert.assertEquals("We should have found four items.", 4, result.size());
+        assertEquals(4, result.size(), "We should have found four items.");
     }
 
     /**

test/unit/org/openstreetmap/josm/data/osm/FilterTest.java

@@ -52 +52 @@
         ds.addPrimitive(n2);
 
         Collection<OsmPrimitive> all = new HashSet<>();
-        all.addAll(Arrays.asList(new OsmPrimitive[] {n1, n2}));
+        all.addAll(Arrays.asList(n1, n2));
 
         List<Filter> filters = new LinkedList<>();
         Filter f1 = new Filter();
         f1.text = "fixme";
         f1.hiding = true;
-        filters.addAll(Arrays.asList(new Filter[] {f1}));
+        filters.addAll(Arrays.asList(f1));
 
         FilterMatcher filterMatcher = new FilterMatcher();
         filterMatcher.update(filters);
@@ -100 +100 @@
                 f1.hiding = true;
                 Filter f2 = new Filter();
                 f2.text = "highway";
-                filters.addAll(Arrays.asList(new Filter[] {f1, f2}));
+                filters.addAll(Arrays.asList(f1, f2));
                 break;
             }
             case 11: {
@@ -119 +119 @@
                 Filter f2 = new Filter();
                 f2.text = "water";
                 f2.mode = SearchMode.remove;
-                filters.addAll(Arrays.asList(new Filter[] {f1, f2}));
+                filters.addAll(Arrays.asList(f1, f2));
                 break;
             }
             case 13: {
@@ -132 +132 @@
                 f2.mode = SearchMode.remove;
                 Filter f3 = new Filter();
                 f3.text = "natural";
-                filters.addAll(Arrays.asList(new Filter[] {f1, f2, f3}));
+                filters.addAll(Arrays.asList(f1, f2, f3));
                 break;
             }
             case 14: {
@@ -150 +150 @@
                 Filter f4 = new Filter();
                 f4.text = "name";
                 f4.mode = SearchMode.remove;
-                filters.addAll(Arrays.asList(new Filter[] {f1, f2, f3, f4}));
+                filters.addAll(Arrays.asList(f1, f2, f3, f4));
                 break;
             }
             case 15: {
@@ -162 +162 @@
                 f2.text = "water";
                 f2.mode = SearchMode.remove;
                 f2.hiding = true; // Remove only hide flag so water should stay disabled
-                filters.addAll(Arrays.asList(new Filter[] {f1, f2}));
+                filters.addAll(Arrays.asList(f1, f2));
                 break;
             }
             default: throw new AssertionError();
@@ -182 +182 @@
                     foundAtLeastOne = true;
                     if (!osm.get(key).equals(filterCode(osm))) {
                         failedPrimitives.append(String.format(
-                                "Object %s. Expected [%s] but was [%s]%n", osm.toString(), osm.get(key), filterCode(osm)));
+                                "Object %s. Expected [%s] but was [%s]%n", osm, osm.get(key), filterCode(osm)));
                     }
                 }
             }
             assertTrue(foundAtLeastOne);
             if (failedPrimitives.length() != 0)
-                throw new AssertionError(String.format("Run #%d%n%s", i, failedPrimitives.toString()));
+                throw new AssertionError(String.format("Run #%d%n%s", i, failedPrimitives));
         }
     }
 

test/unit/org/openstreetmap/josm/data/osm/NodeDataTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -10 +11 @@
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 
@@ -37 +37 @@
         data.setVersion(14);
         data.setChangesetId(314159);
         final NodeData readData = serializeUnserialize(data);
-        Assert.assertEquals(data.toString(), readData.toString());
+        assertEquals(data.toString(), readData.toString());
     }
 
     /**

test/unit/org/openstreetmap/josm/data/osm/OsmPrimitiveKeyHandlingTest.java

@@ -66 +66 @@
         Node n = new Node();
         n.put("key.1", "value.1");
         n.put("key.2", "value.2");
-        assertTrue(n.get("key.1").equals("value.1"));
-        assertTrue(n.get("key.2").equals("value.2"));
+        assertEquals("value.1", n.get("key.1"));
+        assertEquals("value.2", n.get("key.2"));
         testKeysSize(n, 2);
         assertTrue(n.hasKeys());
         assertTrue(n.hasKey("key.1"));

test/unit/org/openstreetmap/josm/data/osm/OsmPrimitiveTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.Arrays;
 import java.util.HashSet;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -30 +30 @@
     public JOSMTestRules test = new JOSMTestRules();
 
     private void compareReferrers(OsmPrimitive actual, OsmPrimitive... expected) {
-        Assert.assertEquals(new HashSet<>(Arrays.asList(expected)),
-                new HashSet<>(actual.getReferrers()));
+        assertEquals(new HashSet<>(Arrays.asList(expected)), new HashSet<>(actual.getReferrers()));
     }
 
     private final DataSet dataSet = new DataSet();
@@ -148 +147 @@
         dataSet.addPrimitive(w1);
         new Way(w1);
 
-        Assert.assertEquals(n.getReferrers().size(), 1);
-        Assert.assertEquals(n.getReferrers().get(0), w1);
+        assertEquals(n.getReferrers().size(), 1);
+        assertEquals(n.getReferrers().get(0), w1);
     }
 
     @Test
     void testCheckMustBeInDatasate() {
         Node n = new Node();
-        assertThrows(DataIntegrityProblemException.class, () -> n.getReferrers());
+        assertThrows(DataIntegrityProblemException.class, n::getReferrers);
     }
 }

test/unit/org/openstreetmap/josm/data/osm/QuadBucketsTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
+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 static org.openstreetmap.josm.TestUtils.getPrivateField;
 
 import java.io.InputStream;
@@ -14 +17 @@
 import java.util.List;
 import java.util.Random;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -62 +64 @@
         for (OsmPrimitive o: allRelations) {
             ds.removePrimitive(o);
         }
-        Assert.assertTrue(nodes.isEmpty());
-        Assert.assertTrue(ways.isEmpty());
-        Assert.assertTrue(relations.isEmpty());
+        assertTrue(nodes.isEmpty());
+        assertTrue(ways.isEmpty());
+        assertTrue(relations.isEmpty());
     }
 
     private void checkIterator(Iterable<? extends OsmPrimitive> col, int expectedCount) {
         int count = 0;
-        Iterator<? extends OsmPrimitive> it = col.iterator();
-        while (it.hasNext()) {
+        for (OsmPrimitive ignored : col) {
             count++;
-            it.next();
         }
-        Assert.assertEquals(expectedCount, count);
+        assertEquals(expectedCount, count);
     }
 
     /**
@@ -126 +126 @@
 
         qbNodes.add(n1);
         qbNodes.add(n2);
-        Assert.assertEquals(2, qbNodes.size());
-        Assert.assertTrue(qbNodes.contains(n1));
-        Assert.assertTrue(qbNodes.contains(n2));
-        Assert.assertFalse(qbNodes.contains(n3));
+        assertEquals(2, qbNodes.size());
+        assertTrue(qbNodes.contains(n1));
+        assertTrue(qbNodes.contains(n2));
+        assertFalse(qbNodes.contains(n3));
         qbNodes.remove(n1);
-        Assert.assertEquals(1, qbNodes.size());
-        Assert.assertFalse(qbNodes.contains(n1));
-        Assert.assertTrue(qbNodes.contains(n2));
+        assertEquals(1, qbNodes.size());
+        assertFalse(qbNodes.contains(n1));
+        assertTrue(qbNodes.contains(n2));
         qbNodes.remove(n2);
-        Assert.assertEquals(0, qbNodes.size());
-        Assert.assertFalse(qbNodes.contains(n1));
-        Assert.assertFalse(qbNodes.contains(n2));
+        assertEquals(0, qbNodes.size());
+        assertFalse(qbNodes.contains(n1));
+        assertFalse(qbNodes.contains(n2));
 
         qbNodes.addAll(Arrays.asList(n1, n2, n3));
         qbNodes.removeAll(Arrays.asList(n1, n3));
-        Assert.assertEquals(1, qbNodes.size());
-        Assert.assertTrue(qbNodes.contains(n2));
+        assertEquals(1, qbNodes.size());
+        assertTrue(qbNodes.contains(n2));
 
         qbWays.add(w1);
         qbWays.add(w2);
         qbWays.add(w3);
-        Assert.assertEquals(3, qbWays.size());
-        Assert.assertTrue(qbWays.contains(w1));
-        Assert.assertTrue(qbWays.contains(w2));
-        Assert.assertTrue(qbWays.contains(w3));
+        assertEquals(3, qbWays.size());
+        assertTrue(qbWays.contains(w1));
+        assertTrue(qbWays.contains(w2));
+        assertTrue(qbWays.contains(w3));
         qbWays.remove(w1);
-        Assert.assertEquals(2, qbWays.size());
-        Assert.assertFalse(qbWays.contains(w1));
-        Assert.assertTrue(qbWays.contains(w2));
-        Assert.assertTrue(qbWays.contains(w3));
+        assertEquals(2, qbWays.size());
+        assertFalse(qbWays.contains(w1));
+        assertTrue(qbWays.contains(w2));
+        assertTrue(qbWays.contains(w3));
         qbWays.remove(w2);
-        Assert.assertEquals(1, qbWays.size());
-        Assert.assertFalse(qbWays.contains(w1));
-        Assert.assertFalse(qbWays.contains(w2));
-        Assert.assertTrue(qbWays.contains(w3));
+        assertEquals(1, qbWays.size());
+        assertFalse(qbWays.contains(w1));
+        assertFalse(qbWays.contains(w2));
+        assertTrue(qbWays.contains(w3));
         qbWays.remove(w3);
-        Assert.assertEquals(0, qbWays.size());
-        Assert.assertFalse(qbWays.contains(w1));
-        Assert.assertFalse(qbWays.contains(w2));
-        Assert.assertFalse(qbWays.contains(w3));
+        assertEquals(0, qbWays.size());
+        assertFalse(qbWays.contains(w1));
+        assertFalse(qbWays.contains(w2));
+        assertFalse(qbWays.contains(w3));
 
         qbWays.clear();
-        Assert.assertEquals(0, qbWays.size());
+        assertEquals(0, qbWays.size());
         List<Way> allWays = new ArrayList<>(Arrays.asList(w1, w2, w3));
         qbWays.addAll(allWays);
-        Assert.assertEquals(3, qbWays.size());
+        assertEquals(3, qbWays.size());
         int count = 0;
         for (Way w : qbWays) {
-            Assert.assertTrue(allWays.contains(w));
+            assertTrue(allWays.contains(w));
             count++;
         }
-        Assert.assertEquals(3, count);
+        assertEquals(3, count);
         // test remove with iterator
         Iterator<Way> iter = qbWays.iterator();
         while (iter.hasNext()) {
             iter.next();
             iter.remove();
             count--;
-            Assert.assertEquals(count, qbWays.size());
+            assertEquals(count, qbWays.size());
         }
-        Assert.assertEquals(0, qbWays.size());
+        assertEquals(0, qbWays.size());
 
     }
 
@@ -220 +220 @@
             w.setNodes(nodes);
             ds.addPrimitive(w);
         }
-        Assert.assertEquals(NUM_COMPLETE_WAYS, ds.getWays().size());
-        Assert.assertEquals(NUM_COMPLETE_WAYS * NUM_NODES_PER_WAY, ds.getNodes().size());
+        assertEquals(NUM_COMPLETE_WAYS, ds.getWays().size());
+        assertEquals(NUM_COMPLETE_WAYS * NUM_NODES_PER_WAY, ds.getNodes().size());
 
         // add some incomplete nodes
         for (int i = 0; i < NUM_INCOMPLETE_NODES; i++) {
@@ -229 +229 @@
             n.setIncomplete(true);
             ds.addPrimitive(n);
         }
-        Assert.assertEquals(NUM_COMPLETE_WAYS * NUM_NODES_PER_WAY + NUM_INCOMPLETE_NODES, ds.getNodes().size());
+        assertEquals(NUM_COMPLETE_WAYS * NUM_NODES_PER_WAY + NUM_INCOMPLETE_NODES, ds.getNodes().size());
         // add some incomplete ways
         List<Way> incompleteWays = new ArrayList<>();
         for (int i = 0; i < NUM_INCOMPLETE_WAYS; i++) {
@@ -238 +238 @@
             w.setIncomplete(true);
             ds.addPrimitive(w);
         }
-        Assert.assertEquals(NUM_COMPLETE_WAYS + NUM_INCOMPLETE_WAYS, ds.getWays().size());
+        assertEquals(NUM_COMPLETE_WAYS + NUM_INCOMPLETE_WAYS, ds.getWays().size());
 
         BBox planet = new BBox(-180, -90, 180, 90);
         // incomplete ways should not be found with search
-        Assert.assertEquals(NUM_COMPLETE_WAYS, ds.searchWays(planet).size());
+        assertEquals(NUM_COMPLETE_WAYS, ds.searchWays(planet).size());
         // incomplete ways are only retrieved via iterator or object reference
         for (Way w : incompleteWays) {
-            Assert.assertTrue(ds.getWays().contains(w));
+            assertTrue(ds.getWays().contains(w));
         }
 
         QuadBuckets<Way> qb = new QuadBuckets<>();
         qb.addAll(ds.getWays());
         int count = qb.size();
-        Assert.assertEquals(count, ds.getWays().size());
+        assertEquals(count, ds.getWays().size());
         Iterator<Way> iter = qb.iterator();
         while (iter.hasNext()) {
             iter.next();
             iter.remove();
             count--;
-            Assert.assertEquals(count, qb.size());
+            assertEquals(count, qb.size());
         }
-        Assert.assertEquals(0, qb.size());
+        assertEquals(0, qb.size());
     }
 }

test/unit/org/openstreetmap/josm/data/osm/RelationTest.java

@@ -6 +6 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -61 +60 @@
 
         BBox bbox = new BBox(w1);
         bbox.add(n3.getBBox());
-        Assert.assertEquals(bbox, r1.getBBox());
-        Assert.assertEquals(bbox, r2.getBBox());
+        assertEquals(bbox, r1.getBBox());
+        assertEquals(bbox, r2.getBBox());
 
         n3.setCoor(new LatLon(40, 40));
         bbox.add(n3.getBBox());
-        Assert.assertEquals(bbox, r1.getBBox());
-        Assert.assertEquals(bbox, r2.getBBox());
+        assertEquals(bbox, r1.getBBox());
+        assertEquals(bbox, r2.getBBox());
 
         r1.removeMembersFor(r2);
-        Assert.assertEquals(w1.getBBox(), r1.getBBox());
-        Assert.assertEquals(bbox, r2.getBBox());
+        assertEquals(w1.getBBox(), r1.getBBox());
+        assertEquals(bbox, r2.getBBox());
 
         w1.addNode(n3);
-        Assert.assertEquals(w1.getBBox(), r1.getBBox());
-        Assert.assertEquals(w1.getBBox(), r2.getBBox());
+        assertEquals(w1.getBBox(), r1.getBBox());
+        assertEquals(w1.getBBox(), r2.getBBox());
 
         // create incomplete node and add it to the relation, this must not change the bbox
         BBox oldBBox = r2.getBBox();
@@ -84 +83 @@
         ds.addPrimitive(n4);
         r2.addMember(new RelationMember("", n4));
 
-        Assert.assertEquals(oldBBox, r2.getBBox());
+        assertEquals(oldBBox, r2.getBBox());
     }
 
     @Test
@@ -98 +97 @@
         r1.getBBox();
         r1.addMember(new RelationMember("", w1));
 
-        Assert.assertEquals(new BBox(w1), r1.getBBox());
+        assertEquals(new BBox(w1), r1.getBBox());
 
         DataSet ds = new DataSet();
         ds.addPrimitive(n1);
@@ -106 +105 @@
         ds.addPrimitive(w1);
         ds.addPrimitive(r1);
 
-        Assert.assertEquals(new BBox(w1), r1.getBBox());
+        assertEquals(new BBox(w1), r1.getBBox());
 
         ds.removePrimitive(r1);
 
         n1.setCoor(new LatLon(30, 40));
-        Assert.assertEquals(new BBox(w1), r1.getBBox());
+        assertEquals(new BBox(w1), r1.getBBox());
 
         ds.addPrimitive(r1);
-        Assert.assertEquals(new BBox(w1), r1.getBBox());
+        assertEquals(new BBox(w1), r1.getBBox());
     }
 
     /**

test/unit/org/openstreetmap/josm/data/osm/TagCollectionTest.java

@@ -3 +3 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
@@ -16 +17 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
-
 import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 
 /**
  * Tests of {@link TagCollection}.
@@ -557 +557 @@
         assertEquals("x", tagged.get("k3"));
         TagCollection d = new TagCollection(Arrays.asList(tagEmpty));
         d.applyTo(tagged);
-        assertEquals(null, tagged.get("k"));
+        assertNull(tagged.get("k"));
     }
 
     /**
@@ -590 +590 @@
         c.replaceTagsOf(tagged);
         assertEquals("v", tagged.get("k"));
         assertEquals("b", tagged.get("k2"));
-        assertEquals(null, tagged.get("k3"));
+        assertNull(tagged.get("k3"));
     }
 
     /**
@@ -608 +608 @@
         assertEquals("b", tagged.get("k2"));
         assertEquals("v", tagged2.get("k"));
         assertEquals("b", tagged2.get("k2"));
-        assertEquals(null, tagged2.get("k3"));
+        assertNull(tagged2.get("k3"));
     }
 
     /**

test/unit/org/openstreetmap/josm/data/osm/WayDataTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.Arrays;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -30 +31 @@
                 readData = in.readObject();
             }
         }
-        Assert.assertEquals(data.toString(), readData.toString());
+        assertEquals(data.toString(), readData.toString());
     }
 }

test/unit/org/openstreetmap/josm/data/osm/WaySegmentTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.Arrays;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -41 +42 @@
         w.addNode(n1);
         w.addNode(n4);
         w.addNode(n1);
-        Assert.assertEquals(WaySegment.forNodePair(w, n1, n2).getLowerIndex(), 0);
-        Assert.assertEquals(WaySegment.forNodePair(w, n1, n3).getLowerIndex(), 2);
-        Assert.assertEquals(WaySegment.forNodePair(w, n1, n4).getLowerIndex(), 4);
-        Assert.assertEquals(WaySegment.forNodePair(w, n4, n1).getLowerIndex(), 5);
+        assertEquals(WaySegment.forNodePair(w, n1, n2).getLowerIndex(), 0);
+        assertEquals(WaySegment.forNodePair(w, n1, n3).getLowerIndex(), 2);
+        assertEquals(WaySegment.forNodePair(w, n1, n4).getLowerIndex(), 4);
+        assertEquals(WaySegment.forNodePair(w, n4, n1).getLowerIndex(), 5);
         try {
-            Assert.assertEquals(WaySegment.forNodePair(w, n3, n4).getLowerIndex(), 5);
+            assertEquals(WaySegment.forNodePair(w, n3, n4).getLowerIndex(), 5);
             throw new IllegalStateException("Expecting IllegalArgumentException");
         } catch (IllegalArgumentException expected) {
             System.out.println("Expected exception: " + expected.getMessage());

test/unit/org/openstreetmap/josm/data/preferences/StrokePropertyTest.java

@@ -3 +3 @@
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import java.awt.BasicStroke;
 
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.spi.preferences.Config;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 
-import org.junit.jupiter.api.Test;
-
 /**
  * Test {@link StrokeProperty}
  * @author Michael Zangl
@@ -29 +29 @@
         BasicStroke bs = property.get();
         assertWide(bs);
         assertEquals(11, bs.getLineWidth(), 1e-10);
-        assertEquals(null, bs.getDashArray());
+        assertNull(bs.getDashArray());
 
         Config.getPref().put("x", ".5");
         bs = property.get();
         assertThin(bs);
         assertEquals(.5, bs.getLineWidth(), 1e-10);
-        assertEquals(null, bs.getDashArray());
+        assertNull(bs.getDashArray());
 
         Config.getPref().put("x", "2 1");
         bs = property.get();
@@ -53 +53 @@
         bs = property.get();
         assertThin(bs);
         assertEquals(1, bs.getLineWidth(), 1e-10);
-        assertEquals(null, bs.getDashArray());
+        assertNull(bs.getDashArray());
 
         // ignore dashes
         Config.getPref().put("x", "11 0 0 0.0001");
         bs = property.get();
         assertWide(bs);
         assertEquals(11, bs.getLineWidth(), 1e-10);
-        assertEquals(null, bs.getDashArray());
+        assertNull(bs.getDashArray());
     }
 
     /**
@@ -73 +73 @@
 
         assertWide(bs);
         assertEquals(12, bs.getLineWidth(), 1e-10);
-        assertEquals(null, bs.getDashArray());
+        assertNull(bs.getDashArray());
 
         property.put(new BasicStroke(2, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1, new float[] {0.1f, 1, 10}, 0));
         bs = property.get();

test/unit/org/openstreetmap/josm/data/projection/EllipsoidTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection;
 
+import static org.junit.jupiter.api.Assertions.fail;
+
 import java.security.SecureRandom;
 import java.util.Random;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.coor.LatLon;
 
@@ -36 +37 @@
                 if (!(Math.abs(lat - ll.lat()) < EPSILON && Math.abs(lon - ll.lon()) < EPSILON)) {
                     String error = String.format("point: %s iterations: %s current: %s errorLat: %s errorLon %s",
                             new LatLon(lat, lon), i, ll, Math.abs(lat - ll.lat()), Math.abs(lon - ll.lon()));
-                    System.err.println(error);
-                    Assert.fail();
+                    fail(error);
                 }
             }
 

test/unit/org/openstreetmap/josm/data/projection/ProjectionRefTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection;
 
+import static org.junit.jupiter.api.Assertions.fail;
+
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
@@ -33 +35 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.data.Bounds;
@@ -132 +133 @@
                 if (line.startsWith("<")) {
                     Matcher m = projPattern.matcher(line);
                     if (!m.matches()) {
-                        Assert.fail("unable to parse line: " + line);
+                        fail("unable to parse line: " + line);
                     }
                     String code = m.group(1);
                     String def = m.group(2).trim();
@@ -382 +383 @@
         Collection<RefEntry> refs = readData();
         refs.stream().map(ref -> ref.code).forEach(allCodes::remove);
         if (!allCodes.isEmpty()) {
-            Assert.fail("no reference data for following projections: "+allCodes);
+            fail("no reference data for following projections: "+allCodes);
         }
 
         refs.parallelStream().forEach(ref -> {
             String def0 = Projections.getInit(ref.code);
             if (def0 == null) {
-                Assert.fail("unknown code: "+ref.code);
+                fail("unknown code: "+ref.code);
             }
             if (!ref.def.equals(def0)) {
                 failures.add("definitions for ".concat(ref.code).concat(" do not match\n"));
@@ -410 +411 @@
                         String errorEN = String.format("%s (%s): Projecting latlon(%s,%s):%n" +
                                 "        expected: eastnorth(%s,%s),%n" +
                                 "        but got:  eastnorth(%s,%s)!%n",
-                                proj.toString(), proj.toCode(), ll.lat(), ll.lon(), enRef.east(), enRef.north(), en.east(), en.north());
+                                proj, proj.toCode(), ll.lat(), ll.lon(), enRef.east(), enRef.north(), en.east(), en.north());
                         failures.add(errorEN);
                         failingProjs.computeIfAbsent(proj.proj.getProj4Id(), x -> new TreeSet<>()).add(ref.code);
                     }
@@ -418 +419 @@
             }
         });
         if (!failures.isEmpty()) {
-            System.err.println(failures.toString());
+            System.err.println(failures);
             throw new AssertionError("Failing:\n" +
                     failingProjs.keySet().size() + " projections: " + failingProjs.keySet() + "\n" +
                     failingProjs.values().stream().mapToInt(Set::size).sum() + " definitions: " + failingProjs);

test/unit/org/openstreetmap/josm/data/projection/ProjectionRegressionTest.java

@@ -177 +177 @@
                 String error = String.format("%s (%s): Projecting latlon(%s,%s):%n" +
                         "        expected: eastnorth(%s,%s),%n" +
                         "        but got:  eastnorth(%s,%s)!%n",
-                        proj.toString(), data.code, data.ll.lat(), data.ll.lon(), data.en.east(), data.en.north(), en.east(), en.north());
+                        proj, data.code, data.ll.lat(), data.ll.lon(), data.en.east(), data.en.north(), en.east(), en.north());
                 fail.append(error);
             }
             if (!(java9 ? equalsJava9(ll2, data.ll2) : ll2.equals(data.ll2))) {
                 String error = String.format("%s (%s): Inverse projecting eastnorth(%s,%s):%n" +
                         "        expected: latlon(%s,%s),%n" +
                         "        but got:  latlon(%s,%s)!%n",
-                        proj.toString(), data.code, data.en.east(), data.en.north(), data.ll2.lat(), data.ll2.lon(), ll2.lat(), ll2.lon());
+                        proj, data.code, data.en.east(), data.en.north(), data.ll2.lat(), data.ll2.lon(), ll2.lat(), ll2.lon());
                 fail.append(error);
             }
         }
 
         if (fail.length() > 0) {
-            System.err.println(fail.toString());
+            System.err.println(fail);
             throw new AssertionError(fail.toString());
         }
     }

test/unit/org/openstreetmap/josm/data/projection/ProjectionsTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection;
 
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
 

test/unit/org/openstreetmap/josm/data/projection/ProjectionTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.projection;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import java.security.SecureRandom;
 import java.util.Arrays;
@@ -9 +10 @@
 import java.util.HashSet;
 import java.util.Random;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
@@ -38 +38 @@
         testProjection(Projections.getProjectionByCode("EPSG:3301")); // Lambert EST
 
         for (int i = 0; i <= 3; ++i) {
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(27561+i))); // Lambert 4 Zones France
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (27561 + i))); // Lambert 4 Zones France
         }
 
         for (int i = 0; i <= 4; ++i) {
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(2176+i))); // PUWG Poland
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (2176 + i))); // PUWG Poland
         }
 
         testProjection(Projections.getProjectionByCode("EPSG:21781")); // Swiss grid
 
         for (int i = 0; i <= 60; ++i) {
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(32601+i))); // UTM North
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(32701+i))); // UTM South
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (32601 + i))); // UTM North
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (32701 + i))); // UTM South
         }
 
         for (String c : Arrays.asList("2969", "2970", "2972", "2973")) {
@@ -57 +57 @@
         }
 
         for (int i = 0; i <= 8; ++i) {
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(3942+i))); // Lambert CC9 Zones France
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (3942 + i))); // Lambert CC9 Zones France
         }
 
         for (int i = 0; i <= 17; ++i) {
-            testProjection(Projections.getProjectionByCode("EPSG:"+Integer.toString(102421+i))); // WGS_1984_ARC_System Zones
+            testProjection(Projections.getProjectionByCode("EPSG:"+ (102421 + i))); // WGS_1984_ARC_System Zones
         }
 
         testProjection(Projections.getProjectionByCode("EPSG:102016")); // North Pole
         testProjection(Projections.getProjectionByCode("EPSG:102019")); // South Pole
 
         if (error) {
-            System.err.println(text);
-            Assert.fail();
+            fail(text);
         }
     }
 
@@ -78 +77 @@
             double maxErrLat = 0, maxErrLon = 0;
             Bounds b = p.getWorldBoundsLatLon();
 
-            text += String.format("*** %s %s%n", p.toString(), p.toCode());
+            text += String.format("*** %s %s%n", p, p.toCode());
             for (int num = 0; num < 1000; ++num) {
 
                 LatLon ll0 = random(b);
@@ -146 +145 @@
         testProj("eqc", 1e-5, "");
 
         if (error2) {
-            System.err.println(text2);
-            Assert.fail();
+            fail(text2);
         }
         assertTrue(projIds.isEmpty(), "missing test: "+projIds);
     }

test/unit/org/openstreetmap/josm/data/validation/routines/DomainValidatorTest.java

@@ -16 +16 @@
  */
 package org.openstreetmap.josm.data.validation.routines;
 
-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.junit.jupiter.api.Assertions.fail;
 
 import java.lang.reflect.Field;
@@ -55 +55 @@
      */
     @Test
     void testValidDomains() {
-        assertTrue("apache.org should validate", validator.isValid("apache.org"));
-        assertTrue("www.google.com should validate", validator.isValid("www.google.com"));
+        assertTrue(validator.isValid("apache.org"), "apache.org should validate");
+        assertTrue(validator.isValid("www.google.com"), "www.google.com should validate");
 
-        assertTrue("test-domain.com should validate", validator.isValid("test-domain.com"));
-        assertTrue("test---domain.com should validate", validator.isValid("test---domain.com"));
-        assertTrue("test-d-o-m-ain.com should validate", validator.isValid("test-d-o-m-ain.com"));
-        assertTrue("two-letter domain label should validate", validator.isValid("as.uk"));
+        assertTrue(validator.isValid("test-domain.com"), "test-domain.com should validate");
+        assertTrue(validator.isValid("test---domain.com"), "test---domain.com should validate");
+        assertTrue(validator.isValid("test-d-o-m-ain.com"), "test-d-o-m-ain.com should validate");
+        assertTrue(validator.isValid("as.uk"), "two-letter domain label should validate");
 
-        assertTrue("case-insensitive ApAchE.Org should validate", validator.isValid("ApAchE.Org"));
+        assertTrue(validator.isValid("ApAchE.Org"), "case-insensitive ApAchE.Org should validate");
 
-        assertTrue("single-character domain label should validate", validator.isValid("z.com"));
+        assertTrue(validator.isValid("z.com"), "single-character domain label should validate");
 
-        assertTrue("i.have.an-example.domain.name should validate", validator.isValid("i.have.an-example.domain.name"));
+        assertTrue(validator.isValid("i.have.an-example.domain.name"), "i.have.an-example.domain.name should validate");
     }
 
     /**
@@ -75 +75 @@
      */
     @Test
     void testInvalidDomains() {
-        assertFalse("bare TLD .org shouldn't validate", validator.isValid(".org"));
-        assertFalse("domain name with spaces shouldn't validate", validator.isValid(" apache.org "));
-        assertFalse("domain name containing spaces shouldn't validate", validator.isValid("apa che.org"));
-        assertFalse("domain name starting with dash shouldn't validate", validator.isValid("-testdomain.name"));
-        assertFalse("domain name ending with dash shouldn't validate", validator.isValid("testdomain-.name"));
-        assertFalse("domain name starting with multiple dashes shouldn't validate", validator.isValid("---c.com"));
-        assertFalse("domain name ending with multiple dashes shouldn't validate", validator.isValid("c--.com"));
-        assertFalse("domain name with invalid TLD shouldn't validate", validator.isValid("apache.rog"));
+        assertFalse(validator.isValid(".org"), "bare TLD .org shouldn't validate");
+        assertFalse(validator.isValid(" apache.org "), "domain name with spaces shouldn't validate");
+        assertFalse(validator.isValid("apa che.org"), "domain name containing spaces shouldn't validate");
+        assertFalse(validator.isValid("-testdomain.name"), "domain name starting with dash shouldn't validate");
+        assertFalse(validator.isValid("testdomain-.name"), "domain name ending with dash shouldn't validate");
+        assertFalse(validator.isValid("---c.com"), "domain name starting with multiple dashes shouldn't validate");
+        assertFalse(validator.isValid("c--.com"), "domain name ending with multiple dashes shouldn't validate");
+        assertFalse(validator.isValid("apache.rog"), "domain name with invalid TLD shouldn't validate");
 
-        assertFalse("URL shouldn't validate", validator.isValid("http://www.apache.org"));
-        assertFalse("Empty string shouldn't validate as domain name", validator.isValid(" "));
-        assertFalse("Null shouldn't validate as domain name", validator.isValid(null));
+        assertFalse(validator.isValid("http://www.apache.org"), "URL shouldn't validate");
+        assertFalse(validator.isValid(" "), "Empty string shouldn't validate as domain name");
+        assertFalse(validator.isValid(null), "Null shouldn't validate as domain name");
     }
 
     /**
@@ -95 +95 @@
     @Test
     void testTopLevelDomains() {
         // infrastructure TLDs
-        assertTrue(".arpa should validate as iTLD", validator.isValidInfrastructureTld(".arpa"));
-        assertFalse(".com shouldn't validate as iTLD", validator.isValidInfrastructureTld(".com"));
+        assertTrue(validator.isValidInfrastructureTld(".arpa"), ".arpa should validate as iTLD");
+        assertFalse(validator.isValidInfrastructureTld(".com"), ".com shouldn't validate as iTLD");
 
         // generic TLDs
-        assertTrue(".name should validate as gTLD", validator.isValidGenericTld(".name"));
-        assertFalse(".us shouldn't validate as gTLD", validator.isValidGenericTld(".us"));
+        assertTrue(validator.isValidGenericTld(".name"), ".name should validate as gTLD");
+        assertFalse(validator.isValidGenericTld(".us"), ".us shouldn't validate as gTLD");
 
         // country code TLDs
-        assertTrue(".uk should validate as ccTLD", validator.isValidCountryCodeTld(".uk"));
-        assertFalse(".org shouldn't validate as ccTLD", validator.isValidCountryCodeTld(".org"));
+        assertTrue(validator.isValidCountryCodeTld(".uk"), ".uk should validate as ccTLD");
+        assertFalse(validator.isValidCountryCodeTld(".org"), ".org shouldn't validate as ccTLD");
 
         // case-insensitive
-        assertTrue(".COM should validate as TLD", validator.isValidTld(".COM"));
-        assertTrue(".BiZ should validate as TLD", validator.isValidTld(".BiZ"));
+        assertTrue(validator.isValidTld(".COM"), ".COM should validate as TLD");
+        assertTrue(validator.isValidTld(".BiZ"), ".BiZ should validate as TLD");
 
         // corner cases
-        assertFalse("invalid TLD shouldn't validate", validator.isValid(".nope")); // TODO this is not guaranteed invalid forever
-        assertFalse("empty string shouldn't validate as TLD", validator.isValid(""));
-        assertFalse("null shouldn't validate as TLD", validator.isValid(null));
+        assertFalse(validator.isValid(".nope"), "invalid TLD shouldn't validate"); // TODO this is not guaranteed invalid forever
+        assertFalse(validator.isValid(""), "empty string shouldn't validate as TLD");
+        assertFalse(validator.isValid(null), "null shouldn't validate as TLD");
     }
 
     /**
@@ -128 +128 @@
        assertEquals(noLocal, validator);
 
        // Default won't allow local
-       assertFalse("localhost.localdomain should validate", noLocal.isValid("localhost.localdomain"));
-       assertFalse("localhost should validate", noLocal.isValid("localhost"));
+       assertFalse(noLocal.isValid("localhost.localdomain"), "localhost.localdomain should validate");
+       assertFalse(noLocal.isValid("localhost"), "localhost should validate");
 
        // But it may be requested
-       assertTrue("localhost.localdomain should validate", allowLocal.isValid("localhost.localdomain"));
-       assertTrue("localhost should validate", allowLocal.isValid("localhost"));
-       assertTrue("hostname should validate", allowLocal.isValid("hostname"));
-       assertTrue("machinename should validate", allowLocal.isValid("machinename"));
+       assertTrue(allowLocal.isValid("localhost.localdomain"), "localhost.localdomain should validate");
+       assertTrue(allowLocal.isValid("localhost"), "localhost should validate");
+       assertTrue(allowLocal.isValid("hostname"), "hostname should validate");
+       assertTrue(allowLocal.isValid("machinename"), "machinename should validate");
 
        // Check the localhost one with a few others
-       assertTrue("apache.org should validate", allowLocal.isValid("apache.org"));
-       assertFalse("domain name with spaces shouldn't validate", allowLocal.isValid(" apache.org "));
+       assertTrue(allowLocal.isValid("apache.org"), "apache.org should validate");
+       assertFalse(allowLocal.isValid(" apache.org "), "domain name with spaces shouldn't validate");
     }
 
     /**
@@ -147 +147 @@
      */
     @Test
     void testIDN() {
-       assertTrue("b\u00fccher.ch in IDN should validate", validator.isValid("www.xn--bcher-kva.ch"));
+       assertTrue(validator.isValid("www.xn--bcher-kva.ch"), "b\u00fccher.ch in IDN should validate");
     }
 
     /**
@@ -160 +160 @@
             System.out.println("Cannot run Unicode IDN tests");
             return; // Cannot run the test
         } // xn--d1abbgf6aiiy.xn--p1ai http://президент.рф
-       assertTrue("b\u00fccher.ch should validate", validator.isValid("www.b\u00fccher.ch"));
-       assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("xn--d1abbgf6aiiy.xn--p1ai"));
-       assertTrue("президент.рф should validate", validator.isValid("президент.рф"));
-       assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("www.\uFFFD.ch"));
+       assertTrue(validator.isValid("www.b\u00fccher.ch"), "b\u00fccher.ch should validate");
+       assertTrue(validator.isValid("xn--d1abbgf6aiiy.xn--p1ai"), "xn--d1abbgf6aiiy.xn--p1ai should validate");
+       assertTrue(validator.isValid("президент.рф"), "президент.рф should validate");
+       assertFalse(validator.isValid("www.\uFFFD.ch"), "www.\uFFFD.ch FFFD should fail");
     }
 
     /**
@@ -171 +171 @@
      */
     @Test
     void testRFC2396domainlabel() { // use fixed valid TLD
-        assertTrue("a.ch should validate", validator.isValid("a.ch"));
-        assertTrue("9.ch should validate", validator.isValid("9.ch"));
-        assertTrue("az.ch should validate", validator.isValid("az.ch"));
-        assertTrue("09.ch should validate", validator.isValid("09.ch"));
-        assertTrue("9-1.ch should validate", validator.isValid("9-1.ch"));
-        assertFalse("91-.ch should not validate", validator.isValid("91-.ch"));
-        assertFalse("-.ch should not validate", validator.isValid("-.ch"));
+        assertTrue(validator.isValid("a.ch"), "a.ch should validate");
+        assertTrue(validator.isValid("9.ch"), "9.ch should validate");
+        assertTrue(validator.isValid("az.ch"), "az.ch should validate");
+        assertTrue(validator.isValid("09.ch"), "09.ch should validate");
+        assertTrue(validator.isValid("9-1.ch"), "9-1.ch should validate");
+        assertFalse(validator.isValid("91-.ch"), "91-.ch should not validate");
+        assertFalse(validator.isValid("-.ch"), "-.ch should not validate");
     }
 
     /**
@@ -186 +186 @@
     @Test
     void testRFC2396toplabel() {
         // These tests use non-existent TLDs so currently need to use a package protected method
-        assertTrue("a.c (alpha) should validate", validator.isValidDomainSyntax("a.c"));
-        assertTrue("a.cc (alpha alpha) should validate", validator.isValidDomainSyntax("a.cc"));
-        assertTrue("a.c9 (alpha alphanum) should validate", validator.isValidDomainSyntax("a.c9"));
-        assertTrue("a.c-9 (alpha - alphanum) should validate", validator.isValidDomainSyntax("a.c-9"));
-        assertTrue("a.c-z (alpha - alpha) should validate", validator.isValidDomainSyntax("a.c-z"));
+        assertTrue(validator.isValidDomainSyntax("a.c"), "a.c (alpha) should validate");
+        assertTrue(validator.isValidDomainSyntax("a.cc"), "a.cc (alpha alpha) should validate");
+        assertTrue(validator.isValidDomainSyntax("a.c9"), "a.c9 (alpha alphanum) should validate");
+        assertTrue(validator.isValidDomainSyntax("a.c-9"), "a.c-9 (alpha - alphanum) should validate");
+        assertTrue(validator.isValidDomainSyntax("a.c-z"), "a.c-z (alpha - alpha) should validate");
 
-        assertFalse("a.9c (alphanum alpha) should fail", validator.isValidDomainSyntax("a.9c"));
-        assertFalse("a.c- (alpha -) should fail", validator.isValidDomainSyntax("a.c-"));
-        assertFalse("a.- (-) should fail", validator.isValidDomainSyntax("a.-"));
-        assertFalse("a.-9 (- alphanum) should fail", validator.isValidDomainSyntax("a.-9"));
+        assertFalse(validator.isValidDomainSyntax("a.9c"), "a.9c (alphanum alpha) should fail");
+        assertFalse(validator.isValidDomainSyntax("a.c-"), "a.c- (alpha -) should fail");
+        assertFalse(validator.isValidDomainSyntax("a.-"), "a.- (-) should fail");
+        assertFalse(validator.isValidDomainSyntax("a.-9"), "a.-9 (- alphanum) should fail");
     }
 
     /**
@@ -203 +203 @@
      */
     @Test
     void testDomainNoDots() {
-        assertTrue("a (alpha) should validate", validator.isValidDomainSyntax("a"));
-        assertTrue("9 (alphanum) should validate", validator.isValidDomainSyntax("9"));
-        assertTrue("c-z (alpha - alpha) should validate", validator.isValidDomainSyntax("c-z"));
+        assertTrue(validator.isValidDomainSyntax("a"), "a (alpha) should validate");
+        assertTrue(validator.isValidDomainSyntax("9"), "9 (alphanum) should validate");
+        assertTrue(validator.isValidDomainSyntax("c-z"), "c-z (alpha - alpha) should validate");
 
-        assertFalse("c- (alpha -) should fail", validator.isValidDomainSyntax("c-"));
-        assertFalse("-c (- alpha) should fail", validator.isValidDomainSyntax("-c"));
-        assertFalse("- (-) should fail", validator.isValidDomainSyntax("-"));
+        assertFalse(validator.isValidDomainSyntax("c-"), "c- (alpha -) should fail");
+        assertFalse(validator.isValidDomainSyntax("-c"), "-c (- alpha) should fail");
+        assertFalse(validator.isValidDomainSyntax("-"), "- (-) should fail");
     }
 
     /**
@@ -217 +217 @@
      */
     @Test
     void testValidator297() {
-        assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("xn--d1abbgf6aiiy.xn--p1ai")); // This uses a valid TLD
+        assertTrue(validator.isValid("xn--d1abbgf6aiiy.xn--p1ai"), "xn--d1abbgf6aiiy.xn--p1ai should validate"); // This uses a valid TLD
      }
 
     /**
@@ -229 +229 @@
         final String longString = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789A";
         assertEquals(63, longString.length()); // 26 * 2 + 11
 
-        assertTrue("63 chars label should validate", validator.isValidDomainSyntax(longString+".com"));
-        assertFalse("64 chars label should fail", validator.isValidDomainSyntax(longString+"x.com"));
+        assertTrue(validator.isValidDomainSyntax(longString+".com"), "63 chars label should validate");
+        assertFalse(validator.isValidDomainSyntax(longString+"x.com"), "64 chars label should fail");
 
-        assertTrue("63 chars TLD should validate", validator.isValidDomainSyntax("test."+longString));
-        assertFalse("64 chars TLD should fail", validator.isValidDomainSyntax("test.x"+longString));
+        assertTrue(validator.isValidDomainSyntax("test."+longString), "63 chars TLD should validate");
+        assertFalse(validator.isValidDomainSyntax("test.x"+longString), "64 chars TLD should fail");
 
         final String longDomain =
                 longString
@@ -241 +241 @@
                 + "." + longString
                 + "." + longString.substring(0, 61);
         assertEquals(253, longDomain.length());
-        assertTrue("253 chars domain should validate", validator.isValidDomainSyntax(longDomain));
-        assertFalse("254 chars domain should fail", validator.isValidDomainSyntax(longDomain+"x"));
+        assertTrue(validator.isValidDomainSyntax(longDomain), "253 chars domain should validate");
+        assertFalse(validator.isValidDomainSyntax(longDomain+"x"), "254 chars domain should fail");
     }
 
     /**
@@ -328 +328 @@
      */
     @Test
     void testEnumIsPublic() {
-        assertTrue(Modifier.isPublic(DomainValidator.ArrayType.class.getModifiers()));
+        assertTrue(Modifier.isPublic(ArrayType.class.getModifiers()));
     }
 
     /**
@@ -337 +337 @@
     @Test
     void testUpdateBaseArrays() {
         try {
-            DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_RO, new String[]{"com"});
+            DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_RO, "com");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException iae) {
             // expected
             Logging.debug(iae.getMessage());
         }
         try {
-            DomainValidator.updateTLDOverride(ArrayType.GENERIC_RO, new String[]{"com"});
+            DomainValidator.updateTLDOverride(ArrayType.GENERIC_RO, "com");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException iae) {
             // expected
             Logging.debug(iae.getMessage());
         }
         try {
-            DomainValidator.updateTLDOverride(ArrayType.INFRASTRUCTURE_RO, new String[]{"com"});
+            DomainValidator.updateTLDOverride(ArrayType.INFRASTRUCTURE_RO, "com");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException iae) {
             // expected
             Logging.debug(iae.getMessage());
         }
         try {
-            DomainValidator.updateTLDOverride(ArrayType.LOCAL_RO, new String[]{"com"});
+            DomainValidator.updateTLDOverride(ArrayType.LOCAL_RO, "com");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException iae) {
             // expected
@@ -387 +387 @@
     @Test
     void testUpdateCountryCode() {
         assertFalse(validator.isValidCountryCodeTld("com")); // cannot be valid
-        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, new String[]{"com"});
+        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, "com");
         assertTrue(validator.isValidCountryCodeTld("com")); // it is now!
-        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"com"});
+        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "com");
         assertFalse(validator.isValidCountryCodeTld("com")); // show that minus overrides the rest
 
         assertTrue(validator.isValidCountryCodeTld("ch"));
-        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"ch"});
+        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "ch");
         assertFalse(validator.isValidCountryCodeTld("ch"));
-        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"xx"});
+        DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "xx");
         assertTrue(validator.isValidCountryCodeTld("ch"));
     }
 
@@ -405 +405 @@
     @Test
     void testUpdateGeneric() {
         assertFalse(validator.isValidGenericTld("ch")); // cannot be valid
-        DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
+        DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
         assertTrue(validator.isValidGenericTld("ch")); // it is now!
-        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"ch"});
+        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "ch");
         assertFalse(validator.isValidGenericTld("ch")); // show that minus overrides the rest
 
         assertTrue(validator.isValidGenericTld("com"));
-        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"com"});
+        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "com");
         assertFalse(validator.isValidGenericTld("com"));
-        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"xx"}); // change the minus list
+        DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "xx"); // change the minus list
         assertTrue(validator.isValidGenericTld("com"));
     }
 
@@ -422 +422 @@
      */
     @Test
     void testCannotUpdate() {
-        DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"}); // OK
+        DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch"); // OK
         DomainValidator dv = DomainValidator.getInstance();
         assertNotNull(dv);
         try {
-            DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
+            DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
             fail("Expected IllegalStateException");
         } catch (IllegalStateException ise) {
             // expected

test/unit/org/openstreetmap/josm/data/validation/routines/DomainValidatorTestIT.java

@@ -38 +38 @@
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
@@ -185 +184 @@
         if (header != null) {
             Logging.warn("        // Taken from " + header);
         }
-        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry<String, String> me = it.next();
+        for (Map.Entry<String, String> me : map.entrySet()) {
             Logging.warn("        \"" + me.getKey() + "\", // " + me.getValue());
         }
         Logging.warn(System.lineSeparator() + "Done");

test/unit/org/openstreetmap/josm/data/validation/routines/EmailValidatorTest.java

@@ -16 +16 @@
  */
 package org.openstreetmap.josm.data.validation.routines;
 
-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.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
@@ -171 +171 @@
             System.out.println("Cannot run Unicode IDN tests");
             return; // Cannot run the test
         }
-        assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("someone@xn--d1abbgf6aiiy.xn--p1ai"));
-        assertTrue("президент.рф should validate", validator.isValid("someone@президент.рф"));
-        assertTrue("www.b\u00fccher.ch should validate", validator.isValid("someone@www.b\u00fccher.ch"));
-        assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("someone@www.\uFFFD.ch"));
-        assertTrue("www.b\u00fccher.ch should validate", validator.isValid("someone@www.b\u00fccher.ch"));
-        assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("someone@www.\uFFFD.ch"));
+        assertTrue(validator.isValid("someone@xn--d1abbgf6aiiy.xn--p1ai"), "xn--d1abbgf6aiiy.xn--p1ai should validate");
+        assertTrue(validator.isValid("someone@президент.рф"), "президент.рф should validate");
+        assertTrue(validator.isValid("someone@www.b\u00fccher.ch"), "www.b\u00fccher.ch should validate");
+        assertFalse(validator.isValid("someone@www.\uFFFD.ch"), "www.\uFFFD.ch FFFD should fail");
+        assertTrue(validator.isValid("someone@www.b\u00fccher.ch"), "www.b\u00fccher.ch should validate");
+        assertFalse(validator.isValid("someone@www.\uFFFD.ch"), "www.\uFFFD.ch FFFD should fail");
     }
 
     /**
@@ -216 +216 @@
     @Test
     void testEmailWithControlChars() {
         for (char c = 0; c < 32; c++) {
-            assertFalse("Test control char " + ((int) c), validator.isValid("foo" + c + "bar@domain.com"));
+            assertFalse(validator.isValid("foo" + c + "bar@domain.com"), "Test control char " + ((int) c));
         }
-        assertFalse("Test control char 127", validator.isValid("foo" + ((char) 127) + "bar@domain.com"));
+        assertFalse(validator.isValid("foo" + ((char) 127) + "bar@domain.com"), "Test control char 127");
     }
 
     /**
@@ -233 +233 @@
        assertEquals(validator, noLocal);
 
        // Depends on the validator
-       assertTrue(
-             "@localhost.localdomain should be accepted but wasn't",
-             allowLocal.isValid("joe@localhost.localdomain")
-       );
-       assertTrue(
-             "@localhost should be accepted but wasn't",
-             allowLocal.isValid("joe@localhost")
-       );
+       assertTrue(allowLocal.isValid("joe@localhost.localdomain"), "@localhost.localdomain should be accepted but wasn't");
+       assertTrue(allowLocal.isValid("joe@localhost"), "@localhost should be accepted but wasn't");
 
-       assertFalse(
-             "@localhost.localdomain should be accepted but wasn't",
-             noLocal.isValid("joe@localhost.localdomain")
-       );
-       assertFalse(
-             "@localhost should be accepted but wasn't",
-             noLocal.isValid("joe@localhost")
-       );
+       assertFalse(noLocal.isValid("joe@localhost.localdomain"), "@localhost.localdomain should be accepted but wasn't");
+       assertFalse(noLocal.isValid("joe@localhost"), "@localhost should be accepted but wasn't");
     }
 
     /**
@@ -258 +246 @@
      */
     @Test
     void testEmailWithSlashes() {
-       assertTrue(
-             "/ and ! valid in username",
-             validator.isValid("joe!/blow@apache.org")
-       );
-       assertFalse(
-             "/ not valid in domain",
-             validator.isValid("joe@ap/ache.org")
-       );
-       assertFalse(
-             "! not valid in domain",
-             validator.isValid("joe@apac!he.org")
-       );
+       assertTrue(validator.isValid("joe!/blow@apache.org"), "/ and ! valid in username");
+       assertFalse(validator.isValid("joe@ap/ache.org"), "/ not valid in domain");
+       assertFalse(validator.isValid("joe@apac!he.org"), "! not valid in domain");
     }
 
     /**
@@ -495 +474 @@
         for (ResultPair resultPair : testEmailFromPerl) {
             String item = resultPair.item;
             if (resultPair.valid) {
-                assertTrue("Should be OK: " + item, validator.isValid(item));
+                assertTrue(validator.isValid(item), "Should be OK: " + item);
             } else {
-                assertFalse("Should fail: " + item, validator.isValid(item));
+                assertFalse(validator.isValid(item), "Should fail: " + item);
             }
         }
     }

test/unit/org/openstreetmap/josm/data/validation/routines/InetAddressValidatorTest.java

@@ -16 +16 @@
  */
 package org.openstreetmap.josm.data.validation.routines;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -46 +46 @@
     @Test
     void testInetAddressesFromTheWild() {
         // CHECKSTYLE.OFF: SingleSpaceSeparator
-        assertTrue("www.apache.org IP should be valid",   validator.isValid("140.211.11.130"));
-        assertTrue("www.l.google.com IP should be valid", validator.isValid("72.14.253.103"));
-        assertTrue("fsf.org IP should be valid",          validator.isValid("199.232.41.5"));
-        assertTrue("appscs.ign.com IP should be valid",   validator.isValid("216.35.123.87"));
+        assertTrue(validator.isValid("140.211.11.130"), "www.apache.org IP should be valid");
+        assertTrue(validator.isValid("72.14.253.103"), "www.l.google.com IP should be valid");
+        assertTrue(validator.isValid("199.232.41.5"), "fsf.org IP should be valid");
+        assertTrue(validator.isValid("216.35.123.87"), "appscs.ign.com IP should be valid");
         // CHECKSTYLE.ON: SingleSpaceSeparator
     }
 
@@ -58 +58 @@
      */
     @Test
     void testVALIDATOR_335() {
-        assertTrue("2001:0438:FFFE:0000:0000:0000:0000:0A35 should be valid",
-                validator.isValid("2001:0438:FFFE:0000:0000:0000:0000:0A35"));
+        assertTrue(validator.isValid("2001:0438:FFFE:0000:0000:0000:0000:0A35"), "2001:0438:FFFE:0000:0000:0000:0000:0A35 should be valid");
     }
 
     /**
@@ -68 +67 @@
     @Test
     void testInetAddressesByClass() {
         // CHECKSTYLE.OFF: SingleSpaceSeparator
-        assertTrue("class A IP should be valid",            validator.isValid("24.25.231.12"));
-        assertFalse("illegal class A IP should be invalid", validator.isValid("2.41.32.324"));
+        assertTrue(validator.isValid("24.25.231.12"), "class A IP should be valid");
+        assertFalse(validator.isValid("2.41.32.324"), "illegal class A IP should be invalid");
 
-        assertTrue("class B IP should be valid",            validator.isValid("135.14.44.12"));
-        assertFalse("illegal class B IP should be invalid", validator.isValid("154.123.441.123"));
+        assertTrue(validator.isValid("135.14.44.12"), "class B IP should be valid");
+        assertFalse(validator.isValid("154.123.441.123"), "illegal class B IP should be invalid");
 
-        assertTrue("class C IP should be valid",            validator.isValid("213.25.224.32"));
-        assertFalse("illegal class C IP should be invalid", validator.isValid("201.543.23.11"));
+        assertTrue(validator.isValid("213.25.224.32"), "class C IP should be valid");
+        assertFalse(validator.isValid("201.543.23.11"), "illegal class C IP should be invalid");
 
-        assertTrue("class D IP should be valid",            validator.isValid("229.35.159.6"));
-        assertFalse("illegal class D IP should be invalid", validator.isValid("231.54.11.987"));
+        assertTrue(validator.isValid("229.35.159.6"), "class D IP should be valid");
+        assertFalse(validator.isValid("231.54.11.987"), "illegal class D IP should be invalid");
 
-        assertTrue("class E IP should be valid",            validator.isValid("248.85.24.92"));
-        assertFalse("illegal class E IP should be invalid", validator.isValid("250.21.323.48"));
+        assertTrue(validator.isValid("248.85.24.92"), "class E IP should be valid");
+        assertFalse(validator.isValid("250.21.323.48"), "illegal class E IP should be invalid");
         // CHECKSTYLE.ON: SingleSpaceSeparator
     }
 
@@ -90 +89 @@
      */
     @Test
     void testReservedInetAddresses() {
-        assertTrue("localhost IP should be valid", validator.isValid("127.0.0.1"));
-        assertTrue("broadcast IP should be valid", validator.isValid("255.255.255.255"));
+        assertTrue(validator.isValid("127.0.0.1"), "localhost IP should be valid");
+        assertTrue(validator.isValid("255.255.255.255"), "broadcast IP should be valid");
     }
 
     /**
@@ -100 +99 @@
     @Test
     void testBrokenInetAddresses() {
         // CHECKSTYLE.OFF: SingleSpaceSeparator
-        assertFalse("IP with characters should be invalid",     validator.isValid("124.14.32.abc"));
-        assertFalse("IP with leading zeroes should be invalid", validator.isValid("124.14.32.01"));
-        assertFalse("IP with three groups should be invalid",   validator.isValid("23.64.12"));
-        assertFalse("IP with five groups should be invalid",    validator.isValid("26.34.23.77.234"));
+        assertFalse(validator.isValid("124.14.32.abc"), "IP with characters should be invalid");
+        assertFalse(validator.isValid("124.14.32.01"), "IP with leading zeroes should be invalid");
+        assertFalse(validator.isValid("23.64.12"), "IP with three groups should be invalid");
+        assertFalse(validator.isValid("26.34.23.77.234"), "IP with five groups should be invalid");
         // CHECKSTYLE.ON: SingleSpaceSeparator
     }
 
@@ -120 +119 @@
     void testIPv6() {
         // The original Perl script contained a lot of duplicate tests.
         // I removed the duplicates I noticed, but there may be more.
-        assertFalse("IPV6 empty string should be invalid", validator.isValidInet6Address("")); // empty string
-        assertTrue("IPV6 ::1 should be valid", validator.isValidInet6Address("::1")); // loopback, compressed, non-routable
-        assertTrue("IPV6 :: should be valid", validator.isValidInet6Address("::")); // unspecified, compressed, non-routable
-        assertTrue("IPV6 0:0:0:0:0:0:0:1 should be valid", validator.isValidInet6Address("0:0:0:0:0:0:0:1")); // loopback, full
-        assertTrue("IPV6 0:0:0:0:0:0:0:0 should be valid", validator.isValidInet6Address("0:0:0:0:0:0:0:0")); // unspecified, full
-        assertTrue("IPV6 2001:DB8:0:0:8:800:200C:417A should be valid", validator.isValidInet6Address("2001:DB8:0:0:8:800:200C:417A")); // unicast, full
-        assertTrue("IPV6 FF01:0:0:0:0:0:0:101 should be valid", validator.isValidInet6Address("FF01:0:0:0:0:0:0:101")); // multicast, full
-        assertTrue("IPV6 2001:DB8::8:800:200C:417A should be valid", validator.isValidInet6Address("2001:DB8::8:800:200C:417A")); // unicast, compressed
-        assertTrue("IPV6 FF01::101 should be valid", validator.isValidInet6Address("FF01::101")); // multicast, compressed
-        assertFalse("IPV6 2001:DB8:0:0:8:800:200C:417A:221 should be invalid", validator.isValidInet6Address("2001:DB8:0:0:8:800:200C:417A:221")); // unicast, full
-        assertFalse("IPV6 FF01::101::2 should be invalid", validator.isValidInet6Address("FF01::101::2")); // multicast, compressed
-        assertTrue("IPV6 fe80::217:f2ff:fe07:ed62 should be valid", validator.isValidInet6Address("fe80::217:f2ff:fe07:ed62"));
-        assertTrue("IPV6 2001:0000:1234:0000:0000:C1C0:ABCD:0876 should be valid", validator.isValidInet6Address("2001:0000:1234:0000:0000:C1C0:ABCD:0876"));
-        assertTrue("IPV6 3ffe:0b00:0000:0000:0001:0000:0000:000a should be valid", validator.isValidInet6Address("3ffe:0b00:0000:0000:0001:0000:0000:000a"));
-        assertTrue("IPV6 FF02:0000:0000:0000:0000:0000:0000:0001 should be valid", validator.isValidInet6Address("FF02:0000:0000:0000:0000:0000:0000:0001"));
-        assertTrue("IPV6 0000:0000:0000:0000:0000:0000:0000:0001 should be valid", validator.isValidInet6Address("0000:0000:0000:0000:0000:0000:0000:0001"));
-        assertTrue("IPV6 0000:0000:0000:0000:0000:0000:0000:0000 should be valid", validator.isValidInet6Address("0000:0000:0000:0000:0000:0000:0000:0000"));
-        assertFalse("IPV6 02001:0000:1234:0000:0000:C1C0:ABCD:0876 should be invalid", validator.isValidInet6Address("02001:0000:1234:0000:0000:C1C0:ABCD:0876")); // extra 0 not allowed!
-        assertFalse("IPV6 2001:0000:1234:0000:00001:C1C0:ABCD:0876 should be invalid", validator.isValidInet6Address("2001:0000:1234:0000:00001:C1C0:ABCD:0876")); // extra 0 not allowed!
-        assertFalse("IPV6 2001:0000:1234:0000:0000:C1C0:ABCD:0876 0 should be invalid", validator.isValidInet6Address("2001:0000:1234:0000:0000:C1C0:ABCD:0876 0")); // junk after valid address
-        assertFalse("IPV6 2001:0000:1234: 0000:0000:C1C0:ABCD:0876 should be invalid", validator.isValidInet6Address("2001:0000:1234: 0000:0000:C1C0:ABCD:0876")); // internal space
-        assertFalse("IPV6 3ffe:0b00:0000:0001:0000:0000:000a should be invalid", validator.isValidInet6Address("3ffe:0b00:0000:0001:0000:0000:000a")); // seven segments
-        assertFalse("IPV6 FF02:0000:0000:0000:0000:0000:0000:0000:0001 should be invalid", validator.isValidInet6Address("FF02:0000:0000:0000:0000:0000:0000:0000:0001")); // nine segments
-        assertFalse("IPV6 3ffe:b00::1::a should be invalid", validator.isValidInet6Address("3ffe:b00::1::a")); // double "::"
-        assertFalse("IPV6 ::1111:2222:3333:4444:5555:6666:: should be invalid", validator.isValidInet6Address("::1111:2222:3333:4444:5555:6666::")); // double "::"
-        assertTrue("IPV6 2::10 should be valid", validator.isValidInet6Address("2::10"));
-        assertTrue("IPV6 ff02::1 should be valid", validator.isValidInet6Address("ff02::1"));
-        assertTrue("IPV6 fe80:: should be valid", validator.isValidInet6Address("fe80::"));
-        assertTrue("IPV6 2002:: should be valid", validator.isValidInet6Address("2002::"));
-        assertTrue("IPV6 2001:db8:: should be valid", validator.isValidInet6Address("2001:db8::"));
-        assertTrue("IPV6 2001:0db8:1234:: should be valid", validator.isValidInet6Address("2001:0db8:1234::"));
-        assertTrue("IPV6 ::ffff:0:0 should be valid", validator.isValidInet6Address("::ffff:0:0"));
-        assertTrue("IPV6 1:2:3:4:5:6:7:8 should be valid", validator.isValidInet6Address("1:2:3:4:5:6:7:8"));
-        assertTrue("IPV6 1:2:3:4:5:6::8 should be valid", validator.isValidInet6Address("1:2:3:4:5:6::8"));
-        assertTrue("IPV6 1:2:3:4:5::8 should be valid", validator.isValidInet6Address("1:2:3:4:5::8"));
-        assertTrue("IPV6 1:2:3:4::8 should be valid", validator.isValidInet6Address("1:2:3:4::8"));
-        assertTrue("IPV6 1:2:3::8 should be valid", validator.isValidInet6Address("1:2:3::8"));
-        assertTrue("IPV6 1:2::8 should be valid", validator.isValidInet6Address("1:2::8"));
-        assertTrue("IPV6 1::8 should be valid", validator.isValidInet6Address("1::8"));
-        assertTrue("IPV6 1::2:3:4:5:6:7 should be valid", validator.isValidInet6Address("1::2:3:4:5:6:7"));
-        assertTrue("IPV6 1::2:3:4:5:6 should be valid", validator.isValidInet6Address("1::2:3:4:5:6"));
-        assertTrue("IPV6 1::2:3:4:5 should be valid", validator.isValidInet6Address("1::2:3:4:5"));
-        assertTrue("IPV6 1::2:3:4 should be valid", validator.isValidInet6Address("1::2:3:4"));
-        assertTrue("IPV6 1::2:3 should be valid", validator.isValidInet6Address("1::2:3"));
-        assertTrue("IPV6 ::2:3:4:5:6:7:8 should be valid", validator.isValidInet6Address("::2:3:4:5:6:7:8"));
-        assertTrue("IPV6 ::2:3:4:5:6:7 should be valid", validator.isValidInet6Address("::2:3:4:5:6:7"));
-        assertTrue("IPV6 ::2:3:4:5:6 should be valid", validator.isValidInet6Address("::2:3:4:5:6"));
-        assertTrue("IPV6 ::2:3:4:5 should be valid", validator.isValidInet6Address("::2:3:4:5"));
-        assertTrue("IPV6 ::2:3:4 should be valid", validator.isValidInet6Address("::2:3:4"));
-        assertTrue("IPV6 ::2:3 should be valid", validator.isValidInet6Address("::2:3"));
-        assertTrue("IPV6 ::8 should be valid", validator.isValidInet6Address("::8"));
-        assertTrue("IPV6 1:2:3:4:5:6:: should be valid", validator.isValidInet6Address("1:2:3:4:5:6::"));
-        assertTrue("IPV6 1:2:3:4:5:: should be valid", validator.isValidInet6Address("1:2:3:4:5::"));
-        assertTrue("IPV6 1:2:3:4:: should be valid", validator.isValidInet6Address("1:2:3:4::"));
-        assertTrue("IPV6 1:2:3:: should be valid", validator.isValidInet6Address("1:2:3::"));
-        assertTrue("IPV6 1:2:: should be valid", validator.isValidInet6Address("1:2::"));
-        assertTrue("IPV6 1:: should be valid", validator.isValidInet6Address("1::"));
-        assertTrue("IPV6 1:2:3:4:5::7:8 should be valid", validator.isValidInet6Address("1:2:3:4:5::7:8"));
-        assertFalse("IPV6 1:2:3::4:5::7:8 should be invalid", validator.isValidInet6Address("1:2:3::4:5::7:8")); // Double "::"
-        assertFalse("IPV6 12345::6:7:8 should be invalid", validator.isValidInet6Address("12345::6:7:8"));
-        assertTrue("IPV6 1:2:3:4::7:8 should be valid", validator.isValidInet6Address("1:2:3:4::7:8"));
-        assertTrue("IPV6 1:2:3::7:8 should be valid", validator.isValidInet6Address("1:2:3::7:8"));
-        assertTrue("IPV6 1:2::7:8 should be valid", validator.isValidInet6Address("1:2::7:8"));
-        assertTrue("IPV6 1::7:8 should be valid", validator.isValidInet6Address("1::7:8"));
+        assertFalse(validator.isValidInet6Address(""), "IPV6 empty string should be invalid"); // empty string
+        assertTrue(validator.isValidInet6Address("::1"), "IPV6 ::1 should be valid"); // loopback, compressed, non-routable
+        assertTrue(validator.isValidInet6Address("::"), "IPV6 :: should be valid"); // unspecified, compressed, non-routable
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:0:0:1"), "IPV6 0:0:0:0:0:0:0:1 should be valid"); // loopback, full
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:0:0:0"), "IPV6 0:0:0:0:0:0:0:0 should be valid"); // unspecified, full
+        assertTrue(validator.isValidInet6Address("2001:DB8:0:0:8:800:200C:417A"), "IPV6 2001:DB8:0:0:8:800:200C:417A should be valid"); // unicast, full
+        assertTrue(validator.isValidInet6Address("FF01:0:0:0:0:0:0:101"), "IPV6 FF01:0:0:0:0:0:0:101 should be valid"); // multicast, full
+        assertTrue(validator.isValidInet6Address("2001:DB8::8:800:200C:417A"), "IPV6 2001:DB8::8:800:200C:417A should be valid"); // unicast, compressed
+        assertTrue(validator.isValidInet6Address("FF01::101"), "IPV6 FF01::101 should be valid"); // multicast, compressed
+        assertFalse(validator.isValidInet6Address("2001:DB8:0:0:8:800:200C:417A:221"), "IPV6 2001:DB8:0:0:8:800:200C:417A:221 should be invalid"); // unicast, full
+        assertFalse(validator.isValidInet6Address("FF01::101::2"), "IPV6 FF01::101::2 should be invalid"); // multicast, compressed
+        assertTrue(validator.isValidInet6Address("fe80::217:f2ff:fe07:ed62"), "IPV6 fe80::217:f2ff:fe07:ed62 should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0000:1234:0000:0000:C1C0:ABCD:0876"), "IPV6 2001:0000:1234:0000:0000:C1C0:ABCD:0876 should be valid");
+        assertTrue(validator.isValidInet6Address("3ffe:0b00:0000:0000:0001:0000:0000:000a"), "IPV6 3ffe:0b00:0000:0000:0001:0000:0000:000a should be valid");
+        assertTrue(validator.isValidInet6Address("FF02:0000:0000:0000:0000:0000:0000:0001"), "IPV6 FF02:0000:0000:0000:0000:0000:0000:0001 should be valid");
+        assertTrue(validator.isValidInet6Address("0000:0000:0000:0000:0000:0000:0000:0001"), "IPV6 0000:0000:0000:0000:0000:0000:0000:0001 should be valid");
+        assertTrue(validator.isValidInet6Address("0000:0000:0000:0000:0000:0000:0000:0000"), "IPV6 0000:0000:0000:0000:0000:0000:0000:0000 should be valid");
+        assertFalse(validator.isValidInet6Address("02001:0000:1234:0000:0000:C1C0:ABCD:0876"), "IPV6 02001:0000:1234:0000:0000:C1C0:ABCD:0876 should be invalid"); // extra 0 not allowed!
+        assertFalse(validator.isValidInet6Address("2001:0000:1234:0000:00001:C1C0:ABCD:0876"), "IPV6 2001:0000:1234:0000:00001:C1C0:ABCD:0876 should be invalid"); // extra 0 not allowed!
+        assertFalse(validator.isValidInet6Address("2001:0000:1234:0000:0000:C1C0:ABCD:0876 0"), "IPV6 2001:0000:1234:0000:0000:C1C0:ABCD:0876 0 should be invalid"); // junk after valid address
+        assertFalse(validator.isValidInet6Address("2001:0000:1234: 0000:0000:C1C0:ABCD:0876"), "IPV6 2001:0000:1234: 0000:0000:C1C0:ABCD:0876 should be invalid"); // internal space
+        assertFalse(validator.isValidInet6Address("3ffe:0b00:0000:0001:0000:0000:000a"), "IPV6 3ffe:0b00:0000:0001:0000:0000:000a should be invalid"); // seven segments
+        assertFalse(validator.isValidInet6Address("FF02:0000:0000:0000:0000:0000:0000:0000:0001"), "IPV6 FF02:0000:0000:0000:0000:0000:0000:0000:0001 should be invalid"); // nine segments
+        assertFalse(validator.isValidInet6Address("3ffe:b00::1::a"), "IPV6 3ffe:b00::1::a should be invalid"); // double "::"
+        assertFalse(validator.isValidInet6Address("::1111:2222:3333:4444:5555:6666::"), "IPV6 ::1111:2222:3333:4444:5555:6666:: should be invalid"); // double "::"
+        assertTrue(validator.isValidInet6Address("2::10"), "IPV6 2::10 should be valid");
+        assertTrue(validator.isValidInet6Address("ff02::1"), "IPV6 ff02::1 should be valid");
+        assertTrue(validator.isValidInet6Address("fe80::"), "IPV6 fe80:: should be valid");
+        assertTrue(validator.isValidInet6Address("2002::"), "IPV6 2002:: should be valid");
+        assertTrue(validator.isValidInet6Address("2001:db8::"), "IPV6 2001:db8:: should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:1234::"), "IPV6 2001:0db8:1234:: should be valid");
+        assertTrue(validator.isValidInet6Address("::ffff:0:0"), "IPV6 ::ffff:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5:6:7:8"), "IPV6 1:2:3:4:5:6:7:8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5:6::8"), "IPV6 1:2:3:4:5:6::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5::8"), "IPV6 1:2:3:4:5::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4::8"), "IPV6 1:2:3:4::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3::8"), "IPV6 1:2:3::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2::8"), "IPV6 1:2::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1::8"), "IPV6 1::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1::2:3:4:5:6:7"), "IPV6 1::2:3:4:5:6:7 should be valid");
+        assertTrue(validator.isValidInet6Address("1::2:3:4:5:6"), "IPV6 1::2:3:4:5:6 should be valid");
+        assertTrue(validator.isValidInet6Address("1::2:3:4:5"), "IPV6 1::2:3:4:5 should be valid");
+        assertTrue(validator.isValidInet6Address("1::2:3:4"), "IPV6 1::2:3:4 should be valid");
+        assertTrue(validator.isValidInet6Address("1::2:3"), "IPV6 1::2:3 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3:4:5:6:7:8"), "IPV6 ::2:3:4:5:6:7:8 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3:4:5:6:7"), "IPV6 ::2:3:4:5:6:7 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3:4:5:6"), "IPV6 ::2:3:4:5:6 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3:4:5"), "IPV6 ::2:3:4:5 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3:4"), "IPV6 ::2:3:4 should be valid");
+        assertTrue(validator.isValidInet6Address("::2:3"), "IPV6 ::2:3 should be valid");
+        assertTrue(validator.isValidInet6Address("::8"), "IPV6 ::8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5:6::"), "IPV6 1:2:3:4:5:6:: should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5::"), "IPV6 1:2:3:4:5:: should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4::"), "IPV6 1:2:3:4:: should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3::"), "IPV6 1:2:3:: should be valid");
+        assertTrue(validator.isValidInet6Address("1:2::"), "IPV6 1:2:: should be valid");
+        assertTrue(validator.isValidInet6Address("1::"), "IPV6 1:: should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5::7:8"), "IPV6 1:2:3:4:5::7:8 should be valid");
+        assertFalse(validator.isValidInet6Address("1:2:3::4:5::7:8"), "IPV6 1:2:3::4:5::7:8 should be invalid"); // Double "::"
+        assertFalse(validator.isValidInet6Address("12345::6:7:8"), "IPV6 12345::6:7:8 should be invalid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4::7:8"), "IPV6 1:2:3:4::7:8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3::7:8"), "IPV6 1:2:3::7:8 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2::7:8"), "IPV6 1:2::7:8 should be valid");
+        assertTrue(validator.isValidInet6Address("1::7:8"), "IPV6 1::7:8 should be valid");
         // IPv4 addresses as dotted-quads
-        assertTrue("IPV6 1:2:3:4:5:6:1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3:4:5:6:1.2.3.4"));
-        assertTrue("IPV6 1:2:3:4:5::1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3:4:5::1.2.3.4"));
-        assertTrue("IPV6 1:2:3:4::1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3:4::1.2.3.4"));
-        assertTrue("IPV6 1:2:3::1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3::1.2.3.4"));
-        assertTrue("IPV6 1:2::1.2.3.4 should be valid", validator.isValidInet6Address("1:2::1.2.3.4"));
-        assertTrue("IPV6 1::1.2.3.4 should be valid", validator.isValidInet6Address("1::1.2.3.4"));
-        assertTrue("IPV6 1:2:3:4::5:1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3:4::5:1.2.3.4"));
-        assertTrue("IPV6 1:2:3::5:1.2.3.4 should be valid", validator.isValidInet6Address("1:2:3::5:1.2.3.4"));
-        assertTrue("IPV6 1:2::5:1.2.3.4 should be valid", validator.isValidInet6Address("1:2::5:1.2.3.4"));
-        assertTrue("IPV6 1::5:1.2.3.4 should be valid", validator.isValidInet6Address("1::5:1.2.3.4"));
-        assertTrue("IPV6 1::5:11.22.33.44 should be valid", validator.isValidInet6Address("1::5:11.22.33.44"));
-        assertFalse("IPV6 1::5:400.2.3.4 should be invalid", validator.isValidInet6Address("1::5:400.2.3.4"));
-        assertFalse("IPV6 1::5:260.2.3.4 should be invalid", validator.isValidInet6Address("1::5:260.2.3.4"));
-        assertFalse("IPV6 1::5:256.2.3.4 should be invalid", validator.isValidInet6Address("1::5:256.2.3.4"));
-        assertFalse("IPV6 1::5:1.256.3.4 should be invalid", validator.isValidInet6Address("1::5:1.256.3.4"));
-        assertFalse("IPV6 1::5:1.2.256.4 should be invalid", validator.isValidInet6Address("1::5:1.2.256.4"));
-        assertFalse("IPV6 1::5:1.2.3.256 should be invalid", validator.isValidInet6Address("1::5:1.2.3.256"));
-        assertFalse("IPV6 1::5:300.2.3.4 should be invalid", validator.isValidInet6Address("1::5:300.2.3.4"));
-        assertFalse("IPV6 1::5:1.300.3.4 should be invalid", validator.isValidInet6Address("1::5:1.300.3.4"));
-        assertFalse("IPV6 1::5:1.2.300.4 should be invalid", validator.isValidInet6Address("1::5:1.2.300.4"));
-        assertFalse("IPV6 1::5:1.2.3.300 should be invalid", validator.isValidInet6Address("1::5:1.2.3.300"));
-        assertFalse("IPV6 1::5:900.2.3.4 should be invalid", validator.isValidInet6Address("1::5:900.2.3.4"));
-        assertFalse("IPV6 1::5:1.900.3.4 should be invalid", validator.isValidInet6Address("1::5:1.900.3.4"));
-        assertFalse("IPV6 1::5:1.2.900.4 should be invalid", validator.isValidInet6Address("1::5:1.2.900.4"));
-        assertFalse("IPV6 1::5:1.2.3.900 should be invalid", validator.isValidInet6Address("1::5:1.2.3.900"));
-        assertFalse("IPV6 1::5:300.300.300.300 should be invalid", validator.isValidInet6Address("1::5:300.300.300.300"));
-        assertFalse("IPV6 1::5:3000.30.30.30 should be invalid", validator.isValidInet6Address("1::5:3000.30.30.30"));
-        assertFalse("IPV6 1::400.2.3.4 should be invalid", validator.isValidInet6Address("1::400.2.3.4"));
-        assertFalse("IPV6 1::260.2.3.4 should be invalid", validator.isValidInet6Address("1::260.2.3.4"));
-        assertFalse("IPV6 1::256.2.3.4 should be invalid", validator.isValidInet6Address("1::256.2.3.4"));
-        assertFalse("IPV6 1::1.256.3.4 should be invalid", validator.isValidInet6Address("1::1.256.3.4"));
-        assertFalse("IPV6 1::1.2.256.4 should be invalid", validator.isValidInet6Address("1::1.2.256.4"));
-        assertFalse("IPV6 1::1.2.3.256 should be invalid", validator.isValidInet6Address("1::1.2.3.256"));
-        assertFalse("IPV6 1::300.2.3.4 should be invalid", validator.isValidInet6Address("1::300.2.3.4"));
-        assertFalse("IPV6 1::1.300.3.4 should be invalid", validator.isValidInet6Address("1::1.300.3.4"));
-        assertFalse("IPV6 1::1.2.300.4 should be invalid", validator.isValidInet6Address("1::1.2.300.4"));
-        assertFalse("IPV6 1::1.2.3.300 should be invalid", validator.isValidInet6Address("1::1.2.3.300"));
-        assertFalse("IPV6 1::900.2.3.4 should be invalid", validator.isValidInet6Address("1::900.2.3.4"));
-        assertFalse("IPV6 1::1.900.3.4 should be invalid", validator.isValidInet6Address("1::1.900.3.4"));
-        assertFalse("IPV6 1::1.2.900.4 should be invalid", validator.isValidInet6Address("1::1.2.900.4"));
-        assertFalse("IPV6 1::1.2.3.900 should be invalid", validator.isValidInet6Address("1::1.2.3.900"));
-        assertFalse("IPV6 1::300.300.300.300 should be invalid", validator.isValidInet6Address("1::300.300.300.300"));
-        assertFalse("IPV6 1::3000.30.30.30 should be invalid", validator.isValidInet6Address("1::3000.30.30.30"));
-        assertFalse("IPV6 ::400.2.3.4 should be invalid", validator.isValidInet6Address("::400.2.3.4"));
-        assertFalse("IPV6 ::260.2.3.4 should be invalid", validator.isValidInet6Address("::260.2.3.4"));
-        assertFalse("IPV6 ::256.2.3.4 should be invalid", validator.isValidInet6Address("::256.2.3.4"));
-        assertFalse("IPV6 ::1.256.3.4 should be invalid", validator.isValidInet6Address("::1.256.3.4"));
-        assertFalse("IPV6 ::1.2.256.4 should be invalid", validator.isValidInet6Address("::1.2.256.4"));
-        assertFalse("IPV6 ::1.2.3.256 should be invalid", validator.isValidInet6Address("::1.2.3.256"));
-        assertFalse("IPV6 ::300.2.3.4 should be invalid", validator.isValidInet6Address("::300.2.3.4"));
-        assertFalse("IPV6 ::1.300.3.4 should be invalid", validator.isValidInet6Address("::1.300.3.4"));
-        assertFalse("IPV6 ::1.2.300.4 should be invalid", validator.isValidInet6Address("::1.2.300.4"));
-        assertFalse("IPV6 ::1.2.3.300 should be invalid", validator.isValidInet6Address("::1.2.3.300"));
-        assertFalse("IPV6 ::900.2.3.4 should be invalid", validator.isValidInet6Address("::900.2.3.4"));
-        assertFalse("IPV6 ::1.900.3.4 should be invalid", validator.isValidInet6Address("::1.900.3.4"));
-        assertFalse("IPV6 ::1.2.900.4 should be invalid", validator.isValidInet6Address("::1.2.900.4"));
-        assertFalse("IPV6 ::1.2.3.900 should be invalid", validator.isValidInet6Address("::1.2.3.900"));
-        assertFalse("IPV6 ::300.300.300.300 should be invalid", validator.isValidInet6Address("::300.300.300.300"));
-        assertFalse("IPV6 ::3000.30.30.30 should be invalid", validator.isValidInet6Address("::3000.30.30.30"));
-        assertTrue("IPV6 fe80::217:f2ff:254.7.237.98 should be valid", validator.isValidInet6Address("fe80::217:f2ff:254.7.237.98"));
-        assertTrue("IPV6 ::ffff:192.168.1.26 should be valid", validator.isValidInet6Address("::ffff:192.168.1.26"));
-        assertFalse("IPV6 2001:1:1:1:1:1:255Z255X255Y255 should be invalid", validator.isValidInet6Address("2001:1:1:1:1:1:255Z255X255Y255")); // garbage instead of "." in IPv4
-        assertFalse("IPV6 ::ffff:192x168.1.26 should be invalid", validator.isValidInet6Address("::ffff:192x168.1.26")); // ditto
-        assertTrue("IPV6 ::ffff:192.168.1.1 should be valid", validator.isValidInet6Address("::ffff:192.168.1.1"));
-        assertTrue("IPV6 0:0:0:0:0:0:13.1.68.3 should be valid", validator.isValidInet6Address("0:0:0:0:0:0:13.1.68.3")); // IPv4-compatible IPv6 address, full, deprecated
-        assertTrue("IPV6 0:0:0:0:0:FFFF:129.144.52.38 should be valid", validator.isValidInet6Address("0:0:0:0:0:FFFF:129.144.52.38")); // IPv4-mapped IPv6 address, full
-        assertTrue("IPV6 ::13.1.68.3 should be valid", validator.isValidInet6Address("::13.1.68.3")); // IPv4-compatible IPv6 address, compressed, deprecated
-        assertTrue("IPV6 ::FFFF:129.144.52.38 should be valid", validator.isValidInet6Address("::FFFF:129.144.52.38")); // IPv4-mapped IPv6 address, compressed
-        assertTrue("IPV6 fe80:0:0:0:204:61ff:254.157.241.86 should be valid", validator.isValidInet6Address("fe80:0:0:0:204:61ff:254.157.241.86"));
-        assertTrue("IPV6 fe80::204:61ff:254.157.241.86 should be valid", validator.isValidInet6Address("fe80::204:61ff:254.157.241.86"));
-        assertTrue("IPV6 ::ffff:12.34.56.78 should be valid", validator.isValidInet6Address("::ffff:12.34.56.78"));
-        assertFalse("IPV6 ::ffff:2.3.4 should be invalid", validator.isValidInet6Address("::ffff:2.3.4"));
-        assertFalse("IPV6 ::ffff:257.1.2.3 should be invalid", validator.isValidInet6Address("::ffff:257.1.2.3"));
-        assertFalse("IPV6 1.2.3.4 should be invalid", validator.isValidInet6Address("1.2.3.4"));
-        assertFalse("IPV6 1.2.3.4:1111:2222:3333:4444::5555 should be invalid", validator.isValidInet6Address("1.2.3.4:1111:2222:3333:4444::5555"));
-        assertFalse("IPV6 1.2.3.4:1111:2222:3333::5555 should be invalid", validator.isValidInet6Address("1.2.3.4:1111:2222:3333::5555"));
-        assertFalse("IPV6 1.2.3.4:1111:2222::5555 should be invalid", validator.isValidInet6Address("1.2.3.4:1111:2222::5555"));
-        assertFalse("IPV6 1.2.3.4:1111::5555 should be invalid", validator.isValidInet6Address("1.2.3.4:1111::5555"));
-        assertFalse("IPV6 1.2.3.4::5555 should be invalid", validator.isValidInet6Address("1.2.3.4::5555"));
-        assertFalse("IPV6 1.2.3.4:: should be invalid", validator.isValidInet6Address("1.2.3.4::"));
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5:6:1.2.3.4"), "IPV6 1:2:3:4:5:6:1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4:5::1.2.3.4"), "IPV6 1:2:3:4:5::1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4::1.2.3.4"), "IPV6 1:2:3:4::1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3::1.2.3.4"), "IPV6 1:2:3::1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2::1.2.3.4"), "IPV6 1:2::1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1::1.2.3.4"), "IPV6 1::1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3:4::5:1.2.3.4"), "IPV6 1:2:3:4::5:1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2:3::5:1.2.3.4"), "IPV6 1:2:3::5:1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1:2::5:1.2.3.4"), "IPV6 1:2::5:1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1::5:1.2.3.4"), "IPV6 1::5:1.2.3.4 should be valid");
+        assertTrue(validator.isValidInet6Address("1::5:11.22.33.44"), "IPV6 1::5:11.22.33.44 should be valid");
+        assertFalse(validator.isValidInet6Address("1::5:400.2.3.4"), "IPV6 1::5:400.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:260.2.3.4"), "IPV6 1::5:260.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:256.2.3.4"), "IPV6 1::5:256.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.256.3.4"), "IPV6 1::5:1.256.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.256.4"), "IPV6 1::5:1.2.256.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.3.256"), "IPV6 1::5:1.2.3.256 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:300.2.3.4"), "IPV6 1::5:300.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.300.3.4"), "IPV6 1::5:1.300.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.300.4"), "IPV6 1::5:1.2.300.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.3.300"), "IPV6 1::5:1.2.3.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:900.2.3.4"), "IPV6 1::5:900.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.900.3.4"), "IPV6 1::5:1.900.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.900.4"), "IPV6 1::5:1.2.900.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:1.2.3.900"), "IPV6 1::5:1.2.3.900 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:300.300.300.300"), "IPV6 1::5:300.300.300.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::5:3000.30.30.30"), "IPV6 1::5:3000.30.30.30 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::400.2.3.4"), "IPV6 1::400.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::260.2.3.4"), "IPV6 1::260.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::256.2.3.4"), "IPV6 1::256.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.256.3.4"), "IPV6 1::1.256.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.256.4"), "IPV6 1::1.2.256.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.3.256"), "IPV6 1::1.2.3.256 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::300.2.3.4"), "IPV6 1::300.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.300.3.4"), "IPV6 1::1.300.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.300.4"), "IPV6 1::1.2.300.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.3.300"), "IPV6 1::1.2.3.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::900.2.3.4"), "IPV6 1::900.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.900.3.4"), "IPV6 1::1.900.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.900.4"), "IPV6 1::1.2.900.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::1.2.3.900"), "IPV6 1::1.2.3.900 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::300.300.300.300"), "IPV6 1::300.300.300.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::3000.30.30.30"), "IPV6 1::3000.30.30.30 should be invalid");
+        assertFalse(validator.isValidInet6Address("::400.2.3.4"), "IPV6 ::400.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::260.2.3.4"), "IPV6 ::260.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::256.2.3.4"), "IPV6 ::256.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.256.3.4"), "IPV6 ::1.256.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.256.4"), "IPV6 ::1.2.256.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.3.256"), "IPV6 ::1.2.3.256 should be invalid");
+        assertFalse(validator.isValidInet6Address("::300.2.3.4"), "IPV6 ::300.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.300.3.4"), "IPV6 ::1.300.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.300.4"), "IPV6 ::1.2.300.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.3.300"), "IPV6 ::1.2.3.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("::900.2.3.4"), "IPV6 ::900.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.900.3.4"), "IPV6 ::1.900.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.900.4"), "IPV6 ::1.2.900.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.3.900"), "IPV6 ::1.2.3.900 should be invalid");
+        assertFalse(validator.isValidInet6Address("::300.300.300.300"), "IPV6 ::300.300.300.300 should be invalid");
+        assertFalse(validator.isValidInet6Address("::3000.30.30.30"), "IPV6 ::3000.30.30.30 should be invalid");
+        assertTrue(validator.isValidInet6Address("fe80::217:f2ff:254.7.237.98"), "IPV6 fe80::217:f2ff:254.7.237.98 should be valid");
+        assertTrue(validator.isValidInet6Address("::ffff:192.168.1.26"), "IPV6 ::ffff:192.168.1.26 should be valid");
+        assertFalse(validator.isValidInet6Address("2001:1:1:1:1:1:255Z255X255Y255"), "IPV6 2001:1:1:1:1:1:255Z255X255Y255 should be invalid"); // garbage instead of "." in IPv4
+        assertFalse(validator.isValidInet6Address("::ffff:192x168.1.26"), "IPV6 ::ffff:192x168.1.26 should be invalid"); // ditto
+        assertTrue(validator.isValidInet6Address("::ffff:192.168.1.1"), "IPV6 ::ffff:192.168.1.1 should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:0:13.1.68.3"), "IPV6 0:0:0:0:0:0:13.1.68.3 should be valid"); // IPv4-compatible IPv6 address, full, deprecated
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:FFFF:129.144.52.38"), "IPV6 0:0:0:0:0:FFFF:129.144.52.38 should be valid"); // IPv4-mapped IPv6 address, full
+        assertTrue(validator.isValidInet6Address("::13.1.68.3"), "IPV6 ::13.1.68.3 should be valid"); // IPv4-compatible IPv6 address, compressed, deprecated
+        assertTrue(validator.isValidInet6Address("::FFFF:129.144.52.38"), "IPV6 ::FFFF:129.144.52.38 should be valid"); // IPv4-mapped IPv6 address, compressed
+        assertTrue(validator.isValidInet6Address("fe80:0:0:0:204:61ff:254.157.241.86"), "IPV6 fe80:0:0:0:204:61ff:254.157.241.86 should be valid");
+        assertTrue(validator.isValidInet6Address("fe80::204:61ff:254.157.241.86"), "IPV6 fe80::204:61ff:254.157.241.86 should be valid");
+        assertTrue(validator.isValidInet6Address("::ffff:12.34.56.78"), "IPV6 ::ffff:12.34.56.78 should be valid");
+        assertFalse(validator.isValidInet6Address("::ffff:2.3.4"), "IPV6 ::ffff:2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::ffff:257.1.2.3"), "IPV6 ::ffff:257.1.2.3 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4"), "IPV6 1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4:1111:2222:3333:4444::5555"), "IPV6 1.2.3.4:1111:2222:3333:4444::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4:1111:2222:3333::5555"), "IPV6 1.2.3.4:1111:2222:3333::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4:1111:2222::5555"), "IPV6 1.2.3.4:1111:2222::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4:1111::5555"), "IPV6 1.2.3.4:1111::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4::5555"), "IPV6 1.2.3.4::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4::"), "IPV6 1.2.3.4:: should be invalid");
         // Testing IPv4 addresses represented as dotted-quads
         // Leading zeroes in IPv4 addresses not allowed: some systems treat the leading "0" in ".086" as the start of an octal number
         // Update: The BNF in RFC-3986 explicitly defines the dec-octet (for IPv4 addresses) not to have a leading zero
-        assertFalse("IPV6 fe80:0000:0000:0000:0204:61ff:254.157.241.086 should be invalid", validator.isValidInet6Address("fe80:0000:0000:0000:0204:61ff:254.157.241.086"));
-        assertTrue("IPV6 ::ffff:192.0.2.128 should be valid", validator.isValidInet6Address("::ffff:192.0.2.128")); // but this is OK, since there's a single digit
-        assertFalse("IPV6 XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:1.2.3.4 should be invalid", validator.isValidInet6Address("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:00.00.00.00 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:00.00.00.00"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:000.000.000.000 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:000.000.000.000"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:256.256.256.256 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:256.256.256.256"));
-        assertTrue("IPV6 fe80:0000:0000:0000:0204:61ff:fe9d:f156 should be valid", validator.isValidInet6Address("fe80:0000:0000:0000:0204:61ff:fe9d:f156"));
-        assertTrue("IPV6 fe80:0:0:0:204:61ff:fe9d:f156 should be valid", validator.isValidInet6Address("fe80:0:0:0:204:61ff:fe9d:f156"));
-        assertTrue("IPV6 fe80::204:61ff:fe9d:f156 should be valid", validator.isValidInet6Address("fe80::204:61ff:fe9d:f156"));
-        assertFalse("IPV6 : should be invalid", validator.isValidInet6Address(":"));
-        assertTrue("IPV6 ::ffff:c000:280 should be valid", validator.isValidInet6Address("::ffff:c000:280"));
-        assertFalse("IPV6 1111:2222:3333:4444::5555: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::5555:"));
-        assertFalse("IPV6 1111:2222:3333::5555: should be invalid", validator.isValidInet6Address("1111:2222:3333::5555:"));
-        assertFalse("IPV6 1111:2222::5555: should be invalid", validator.isValidInet6Address("1111:2222::5555:"));
-        assertFalse("IPV6 1111::5555: should be invalid", validator.isValidInet6Address("1111::5555:"));
-        assertFalse("IPV6 ::5555: should be invalid", validator.isValidInet6Address("::5555:"));
-        assertFalse("IPV6 ::: should be invalid", validator.isValidInet6Address(":::"));
-        assertFalse("IPV6 1111: should be invalid", validator.isValidInet6Address("1111:"));
-        assertFalse("IPV6 :1111:2222:3333:4444::5555 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::5555"));
-        assertFalse("IPV6 :1111:2222:3333::5555 should be invalid", validator.isValidInet6Address(":1111:2222:3333::5555"));
-        assertFalse("IPV6 :1111:2222::5555 should be invalid", validator.isValidInet6Address(":1111:2222::5555"));
-        assertFalse("IPV6 :1111::5555 should be invalid", validator.isValidInet6Address(":1111::5555"));
-        assertFalse("IPV6 :::5555 should be invalid", validator.isValidInet6Address(":::5555"));
-        assertTrue("IPV6 2001:0db8:85a3:0000:0000:8a2e:0370:7334 should be valid", validator.isValidInet6Address("2001:0db8:85a3:0000:0000:8a2e:0370:7334"));
-        assertTrue("IPV6 2001:db8:85a3:0:0:8a2e:370:7334 should be valid", validator.isValidInet6Address("2001:db8:85a3:0:0:8a2e:370:7334"));
-        assertTrue("IPV6 2001:db8:85a3::8a2e:370:7334 should be valid", validator.isValidInet6Address("2001:db8:85a3::8a2e:370:7334"));
-        assertTrue("IPV6 2001:0db8:0000:0000:0000:0000:1428:57ab should be valid", validator.isValidInet6Address("2001:0db8:0000:0000:0000:0000:1428:57ab"));
-        assertTrue("IPV6 2001:0db8:0000:0000:0000::1428:57ab should be valid", validator.isValidInet6Address("2001:0db8:0000:0000:0000::1428:57ab"));
-        assertTrue("IPV6 2001:0db8:0:0:0:0:1428:57ab should be valid", validator.isValidInet6Address("2001:0db8:0:0:0:0:1428:57ab"));
-        assertTrue("IPV6 2001:0db8:0:0::1428:57ab should be valid", validator.isValidInet6Address("2001:0db8:0:0::1428:57ab"));
-        assertTrue("IPV6 2001:0db8::1428:57ab should be valid", validator.isValidInet6Address("2001:0db8::1428:57ab"));
-        assertTrue("IPV6 2001:db8::1428:57ab should be valid", validator.isValidInet6Address("2001:db8::1428:57ab"));
-        assertTrue("IPV6 ::ffff:0c22:384e should be valid", validator.isValidInet6Address("::ffff:0c22:384e"));
-        assertTrue("IPV6 2001:0db8:1234:0000:0000:0000:0000:0000 should be valid", validator.isValidInet6Address("2001:0db8:1234:0000:0000:0000:0000:0000"));
-        assertTrue("IPV6 2001:0db8:1234:ffff:ffff:ffff:ffff:ffff should be valid", validator.isValidInet6Address("2001:0db8:1234:ffff:ffff:ffff:ffff:ffff"));
-        assertTrue("IPV6 2001:db8:a::123 should be valid", validator.isValidInet6Address("2001:db8:a::123"));
-        assertFalse("IPV6 123 should be invalid", validator.isValidInet6Address("123"));
-        assertFalse("IPV6 ldkfj should be invalid", validator.isValidInet6Address("ldkfj"));
-        assertFalse("IPV6 2001::FFD3::57ab should be invalid", validator.isValidInet6Address("2001::FFD3::57ab"));
-        assertFalse("IPV6 2001:db8:85a3::8a2e:37023:7334 should be invalid", validator.isValidInet6Address("2001:db8:85a3::8a2e:37023:7334"));
-        assertFalse("IPV6 2001:db8:85a3::8a2e:370k:7334 should be invalid", validator.isValidInet6Address("2001:db8:85a3::8a2e:370k:7334"));
-        assertFalse("IPV6 1:2:3:4:5:6:7:8:9 should be invalid", validator.isValidInet6Address("1:2:3:4:5:6:7:8:9"));
-        assertFalse("IPV6 1::2::3 should be invalid", validator.isValidInet6Address("1::2::3"));
-        assertFalse("IPV6 1:::3:4:5 should be invalid", validator.isValidInet6Address("1:::3:4:5"));
-        assertFalse("IPV6 1:2:3::4:5:6:7:8:9 should be invalid", validator.isValidInet6Address("1:2:3::4:5:6:7:8:9"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:6666:7777:: should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777::"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:6666:: should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:: should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555::"));
-        assertTrue("IPV6 1111:2222:3333:4444:: should be valid", validator.isValidInet6Address("1111:2222:3333:4444::"));
-        assertTrue("IPV6 1111:2222:3333:: should be valid", validator.isValidInet6Address("1111:2222:3333::"));
-        assertTrue("IPV6 1111:2222:: should be valid", validator.isValidInet6Address("1111:2222::"));
-        assertTrue("IPV6 1111:: should be valid", validator.isValidInet6Address("1111::"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:6666::8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::8888"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555::8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555::8888"));
-        assertTrue("IPV6 1111:2222:3333:4444::8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444::8888"));
-        assertTrue("IPV6 1111:2222:3333::8888 should be valid", validator.isValidInet6Address("1111:2222:3333::8888"));
-        assertTrue("IPV6 1111:2222::8888 should be valid", validator.isValidInet6Address("1111:2222::8888"));
-        assertTrue("IPV6 1111::8888 should be valid", validator.isValidInet6Address("1111::8888"));
-        assertTrue("IPV6 ::8888 should be valid", validator.isValidInet6Address("::8888"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555::7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555::7777:8888"));
-        assertTrue("IPV6 1111:2222:3333:4444::7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444::7777:8888"));
-        assertTrue("IPV6 1111:2222:3333::7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333::7777:8888"));
-        assertTrue("IPV6 1111:2222::7777:8888 should be valid", validator.isValidInet6Address("1111:2222::7777:8888"));
-        assertTrue("IPV6 1111::7777:8888 should be valid", validator.isValidInet6Address("1111::7777:8888"));
-        assertTrue("IPV6 ::7777:8888 should be valid", validator.isValidInet6Address("::7777:8888"));
-        assertTrue("IPV6 1111:2222:3333:4444::6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333:4444::6666:7777:8888"));
-        assertTrue("IPV6 1111:2222:3333::6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333::6666:7777:8888"));
-        assertTrue("IPV6 1111:2222::6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222::6666:7777:8888"));
-        assertTrue("IPV6 1111::6666:7777:8888 should be valid", validator.isValidInet6Address("1111::6666:7777:8888"));
-        assertTrue("IPV6 ::6666:7777:8888 should be valid", validator.isValidInet6Address("::6666:7777:8888"));
-        assertTrue("IPV6 1111:2222:3333::5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222:3333::5555:6666:7777:8888"));
-        assertTrue("IPV6 1111:2222::5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222::5555:6666:7777:8888"));
-        assertTrue("IPV6 1111::5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111::5555:6666:7777:8888"));
-        assertTrue("IPV6 ::5555:6666:7777:8888 should be valid", validator.isValidInet6Address("::5555:6666:7777:8888"));
-        assertTrue("IPV6 1111:2222::4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111:2222::4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 1111::4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111::4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 ::4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("::4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 1111::3333:4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("1111::3333:4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 ::3333:4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("::3333:4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 ::2222:3333:4444:5555:6666:7777:8888 should be valid", validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333:4444:5555::123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333:4444:5555::123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333:4444::123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333:4444::123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333::123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333::123.123.123.123"));
-        assertTrue("IPV6 1111:2222::123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222::123.123.123.123"));
-        assertTrue("IPV6 1111::123.123.123.123 should be valid", validator.isValidInet6Address("1111::123.123.123.123"));
-        assertTrue("IPV6 ::123.123.123.123 should be valid", validator.isValidInet6Address("::123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333:4444::6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333:4444::6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333::6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333::6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222::6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222::6666:123.123.123.123"));
-        assertTrue("IPV6 1111::6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111::6666:123.123.123.123"));
-        assertTrue("IPV6 ::6666:123.123.123.123 should be valid", validator.isValidInet6Address("::6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222:3333::5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222:3333::5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222::5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222::5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111::5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111::5555:6666:123.123.123.123"));
-        assertTrue("IPV6 ::5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("::5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111:2222::4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111:2222::4444:5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111::4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111::4444:5555:6666:123.123.123.123"));
-        assertTrue("IPV6 ::4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("::4444:5555:6666:123.123.123.123"));
-        assertTrue("IPV6 1111::3333:4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("1111::3333:4444:5555:6666:123.123.123.123"));
-        assertTrue("IPV6 ::2222:3333:4444:5555:6666:123.123.123.123 should be valid", validator.isValidInet6Address("::2222:3333:4444:5555:6666:123.123.123.123"));
+        assertFalse(validator.isValidInet6Address("fe80:0000:0000:0000:0204:61ff:254.157.241.086"), "IPV6 fe80:0000:0000:0000:0204:61ff:254.157.241.086 should be invalid");
+        assertTrue(validator.isValidInet6Address("::ffff:192.0.2.128"), "IPV6 ::ffff:192.0.2.128 should be valid"); // but this is OK, since there's a single digit
+        assertFalse(validator.isValidInet6Address("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:1.2.3.4"), "IPV6 XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:00.00.00.00"), "IPV6 1111:2222:3333:4444:5555:6666:00.00.00.00 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:000.000.000.000"), "IPV6 1111:2222:3333:4444:5555:6666:000.000.000.000 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:256.256.256.256"), "IPV6 1111:2222:3333:4444:5555:6666:256.256.256.256 should be invalid");
+        assertTrue(validator.isValidInet6Address("fe80:0000:0000:0000:0204:61ff:fe9d:f156"), "IPV6 fe80:0000:0000:0000:0204:61ff:fe9d:f156 should be valid");
+        assertTrue(validator.isValidInet6Address("fe80:0:0:0:204:61ff:fe9d:f156"), "IPV6 fe80:0:0:0:204:61ff:fe9d:f156 should be valid");
+        assertTrue(validator.isValidInet6Address("fe80::204:61ff:fe9d:f156"), "IPV6 fe80::204:61ff:fe9d:f156 should be valid");
+        assertFalse(validator.isValidInet6Address(":"), "IPV6 : should be invalid");
+        assertTrue(validator.isValidInet6Address("::ffff:c000:280"), "IPV6 ::ffff:c000:280 should be valid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::5555:"), "IPV6 1111:2222:3333:4444::5555: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555:"), "IPV6 1111:2222:3333::5555: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::5555:"), "IPV6 1111:2222::5555: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::5555:"), "IPV6 1111::5555: should be invalid");
+        assertFalse(validator.isValidInet6Address("::5555:"), "IPV6 ::5555: should be invalid");
+        assertFalse(validator.isValidInet6Address(":::"), "IPV6 ::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:"), "IPV6 1111: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::5555"), "IPV6 :1111:2222:3333:4444::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::5555"), "IPV6 :1111:2222:3333::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::5555"), "IPV6 :1111:2222::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::5555"), "IPV6 :1111::5555 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::5555"), "IPV6 :::5555 should be invalid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), "IPV6 2001:0db8:85a3:0000:0000:8a2e:0370:7334 should be valid");
+        assertTrue(validator.isValidInet6Address("2001:db8:85a3:0:0:8a2e:370:7334"), "IPV6 2001:db8:85a3:0:0:8a2e:370:7334 should be valid");
+        assertTrue(validator.isValidInet6Address("2001:db8:85a3::8a2e:370:7334"), "IPV6 2001:db8:85a3::8a2e:370:7334 should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:0000:0000:0000:0000:1428:57ab"), "IPV6 2001:0db8:0000:0000:0000:0000:1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:0000:0000:0000::1428:57ab"), "IPV6 2001:0db8:0000:0000:0000::1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:0:0:0:0:1428:57ab"), "IPV6 2001:0db8:0:0:0:0:1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:0:0::1428:57ab"), "IPV6 2001:0db8:0:0::1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8::1428:57ab"), "IPV6 2001:0db8::1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("2001:db8::1428:57ab"), "IPV6 2001:db8::1428:57ab should be valid");
+        assertTrue(validator.isValidInet6Address("::ffff:0c22:384e"), "IPV6 ::ffff:0c22:384e should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:1234:0000:0000:0000:0000:0000"), "IPV6 2001:0db8:1234:0000:0000:0000:0000:0000 should be valid");
+        assertTrue(validator.isValidInet6Address("2001:0db8:1234:ffff:ffff:ffff:ffff:ffff"), "IPV6 2001:0db8:1234:ffff:ffff:ffff:ffff:ffff should be valid");
+        assertTrue(validator.isValidInet6Address("2001:db8:a::123"), "IPV6 2001:db8:a::123 should be valid");
+        assertFalse(validator.isValidInet6Address("123"), "IPV6 123 should be invalid");
+        assertFalse(validator.isValidInet6Address("ldkfj"), "IPV6 ldkfj should be invalid");
+        assertFalse(validator.isValidInet6Address("2001::FFD3::57ab"), "IPV6 2001::FFD3::57ab should be invalid");
+        assertFalse(validator.isValidInet6Address("2001:db8:85a3::8a2e:37023:7334"), "IPV6 2001:db8:85a3::8a2e:37023:7334 should be invalid");
+        assertFalse(validator.isValidInet6Address("2001:db8:85a3::8a2e:370k:7334"), "IPV6 2001:db8:85a3::8a2e:370k:7334 should be invalid");
+        assertFalse(validator.isValidInet6Address("1:2:3:4:5:6:7:8:9"), "IPV6 1:2:3:4:5:6:7:8:9 should be invalid");
+        assertFalse(validator.isValidInet6Address("1::2::3"), "IPV6 1::2::3 should be invalid");
+        assertFalse(validator.isValidInet6Address("1:::3:4:5"), "IPV6 1:::3:4:5 should be invalid");
+        assertFalse(validator.isValidInet6Address("1:2:3::4:5:6:7:8:9"), "IPV6 1:2:3::4:5:6:7:8:9 should be invalid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888"), "IPV6 1111:2222:3333:4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777::"), "IPV6 1111:2222:3333:4444:5555:6666:7777:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::"), "IPV6 1111:2222:3333:4444:5555:6666:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555::"), "IPV6 1111:2222:3333:4444:5555:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::"), "IPV6 1111:2222:3333:4444:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::"), "IPV6 1111:2222:3333:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::"), "IPV6 1111:2222:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111::"), "IPV6 1111:: should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::8888"), "IPV6 1111:2222:3333:4444:5555:6666::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555::8888"), "IPV6 1111:2222:3333:4444:5555::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::8888"), "IPV6 1111:2222:3333:4444::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::8888"), "IPV6 1111:2222:3333::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::8888"), "IPV6 1111:2222::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::8888"), "IPV6 1111::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::8888"), "IPV6 ::8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555::7777:8888"), "IPV6 1111:2222:3333:4444:5555::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::7777:8888"), "IPV6 1111:2222:3333:4444::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::7777:8888"), "IPV6 1111:2222:3333::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::7777:8888"), "IPV6 1111:2222::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::7777:8888"), "IPV6 1111::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::7777:8888"), "IPV6 ::7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::6666:7777:8888"), "IPV6 1111:2222:3333:4444::6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::6666:7777:8888"), "IPV6 1111:2222:3333::6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::6666:7777:8888"), "IPV6 1111:2222::6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::6666:7777:8888"), "IPV6 1111::6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::6666:7777:8888"), "IPV6 ::6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::5555:6666:7777:8888"), "IPV6 1111:2222:3333::5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::5555:6666:7777:8888"), "IPV6 1111:2222::5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::5555:6666:7777:8888"), "IPV6 1111::5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::5555:6666:7777:8888"), "IPV6 ::5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::4444:5555:6666:7777:8888"), "IPV6 1111:2222::4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::4444:5555:6666:7777:8888"), "IPV6 1111::4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::4444:5555:6666:7777:8888"), "IPV6 ::4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::3333:4444:5555:6666:7777:8888"), "IPV6 1111::3333:4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::3333:4444:5555:6666:7777:8888"), "IPV6 ::3333:4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888"), "IPV6 ::2222:3333:4444:5555:6666:7777:8888 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:123.123.123.123"), "IPV6 1111:2222:3333:4444:5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444:5555::123.123.123.123"), "IPV6 1111:2222:3333:4444:5555::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::123.123.123.123"), "IPV6 1111:2222:3333:4444::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::123.123.123.123"), "IPV6 1111:2222:3333::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::123.123.123.123"), "IPV6 1111:2222::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::123.123.123.123"), "IPV6 1111::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("::123.123.123.123"), "IPV6 ::123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333:4444::6666:123.123.123.123"), "IPV6 1111:2222:3333:4444::6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::6666:123.123.123.123"), "IPV6 1111:2222:3333::6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::6666:123.123.123.123"), "IPV6 1111:2222::6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::6666:123.123.123.123"), "IPV6 1111::6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("::6666:123.123.123.123"), "IPV6 ::6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222:3333::5555:6666:123.123.123.123"), "IPV6 1111:2222:3333::5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::5555:6666:123.123.123.123"), "IPV6 1111:2222::5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::5555:6666:123.123.123.123"), "IPV6 1111::5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("::5555:6666:123.123.123.123"), "IPV6 ::5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111:2222::4444:5555:6666:123.123.123.123"), "IPV6 1111:2222::4444:5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::4444:5555:6666:123.123.123.123"), "IPV6 1111::4444:5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("::4444:5555:6666:123.123.123.123"), "IPV6 ::4444:5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("1111::3333:4444:5555:6666:123.123.123.123"), "IPV6 1111::3333:4444:5555:6666:123.123.123.123 should be valid");
+        assertTrue(validator.isValidInet6Address("::2222:3333:4444:5555:6666:123.123.123.123"), "IPV6 ::2222:3333:4444:5555:6666:123.123.123.123 should be valid");
         // Trying combinations of "0" and "::"
         // These are all syntactically correct, but are bad form
         // because "0" adjacent to "::" should be combined into "::"
-        assertTrue("IPV6 ::0:0:0:0:0:0:0 should be valid", validator.isValidInet6Address("::0:0:0:0:0:0:0"));
-        assertTrue("IPV6 ::0:0:0:0:0:0 should be valid", validator.isValidInet6Address("::0:0:0:0:0:0"));
-        assertTrue("IPV6 ::0:0:0:0:0 should be valid", validator.isValidInet6Address("::0:0:0:0:0"));
-        assertTrue("IPV6 ::0:0:0:0 should be valid", validator.isValidInet6Address("::0:0:0:0"));
-        assertTrue("IPV6 ::0:0:0 should be valid", validator.isValidInet6Address("::0:0:0"));
-        assertTrue("IPV6 ::0:0 should be valid", validator.isValidInet6Address("::0:0"));
-        assertTrue("IPV6 ::0 should be valid", validator.isValidInet6Address("::0"));
-        assertTrue("IPV6 0:0:0:0:0:0:0:: should be valid", validator.isValidInet6Address("0:0:0:0:0:0:0::"));
-        assertTrue("IPV6 0:0:0:0:0:0:: should be valid", validator.isValidInet6Address("0:0:0:0:0:0::"));
-        assertTrue("IPV6 0:0:0:0:0:: should be valid", validator.isValidInet6Address("0:0:0:0:0::"));
-        assertTrue("IPV6 0:0:0:0:: should be valid", validator.isValidInet6Address("0:0:0:0::"));
-        assertTrue("IPV6 0:0:0:: should be valid", validator.isValidInet6Address("0:0:0::"));
-        assertTrue("IPV6 0:0:: should be valid", validator.isValidInet6Address("0:0::"));
-        assertTrue("IPV6 0:: should be valid", validator.isValidInet6Address("0::"));
+        assertTrue(validator.isValidInet6Address("::0:0:0:0:0:0:0"), "IPV6 ::0:0:0:0:0:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0:0:0:0:0:0"), "IPV6 ::0:0:0:0:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0:0:0:0:0"), "IPV6 ::0:0:0:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0:0:0:0"), "IPV6 ::0:0:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0:0:0"), "IPV6 ::0:0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0:0"), "IPV6 ::0:0 should be valid");
+        assertTrue(validator.isValidInet6Address("::0"), "IPV6 ::0 should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:0:0::"), "IPV6 0:0:0:0:0:0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0:0::"), "IPV6 0:0:0:0:0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0:0:0::"), "IPV6 0:0:0:0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0:0::"), "IPV6 0:0:0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0:0:0::"), "IPV6 0:0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0:0::"), "IPV6 0:0:: should be valid");
+        assertTrue(validator.isValidInet6Address("0::"), "IPV6 0:: should be valid");
         // Invalid data
-        assertFalse("IPV6 XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX should be invalid", validator.isValidInet6Address("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX"));
+        assertFalse(validator.isValidInet6Address("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX"), "IPV6 XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX should be invalid");
         // Too many components
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777:8888:9999 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:9999"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777:8888:: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888::"));
-        assertFalse("IPV6 ::2222:3333:4444:5555:6666:7777:8888:9999 should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888:9999"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:9999"), "IPV6 1111:2222:3333:4444:5555:6666:7777:8888:9999 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888::"), "IPV6 1111:2222:3333:4444:5555:6666:7777:8888:: should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888:9999"), "IPV6 ::2222:3333:4444:5555:6666:7777:8888:9999 should be invalid");
         // Too few components
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555"));
-        assertFalse("IPV6 1111:2222:3333:4444 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444"));
-        assertFalse("IPV6 1111:2222:3333 should be invalid", validator.isValidInet6Address("1111:2222:3333"));
-        assertFalse("IPV6 1111:2222 should be invalid", validator.isValidInet6Address("1111:2222"));
-        assertFalse("IPV6 1111 should be invalid", validator.isValidInet6Address("1111"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777"), "IPV6 1111:2222:3333:4444:5555:6666:7777 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666"), "IPV6 1111:2222:3333:4444:5555:6666 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555"), "IPV6 1111:2222:3333:4444:5555 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444"), "IPV6 1111:2222:3333:4444 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333"), "IPV6 1111:2222:3333 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222"), "IPV6 1111:2222 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111"), "IPV6 1111 should be invalid");
         // Missing :
-        assertFalse("IPV6 11112222:3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("11112222:3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:22223333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:22223333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:33334444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:33334444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:44445555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:44445555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:55556666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:55556666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:66667777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:66667777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:77778888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:77778888"));
+        assertFalse(validator.isValidInet6Address("11112222:3333:4444:5555:6666:7777:8888"), "IPV6 11112222:3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:22223333:4444:5555:6666:7777:8888"), "IPV6 1111:22223333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:33334444:5555:6666:7777:8888"), "IPV6 1111:2222:33334444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:44445555:6666:7777:8888"), "IPV6 1111:2222:3333:44445555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:55556666:7777:8888"), "IPV6 1111:2222:3333:4444:55556666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:66667777:8888"), "IPV6 1111:2222:3333:4444:5555:66667777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:77778888"), "IPV6 1111:2222:3333:4444:5555:6666:77778888 should be invalid");
         // Missing : intended for ::
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:"));
-        assertFalse("IPV6 1111:2222:3333:4444: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:"));
-        assertFalse("IPV6 1111:2222:3333: should be invalid", validator.isValidInet6Address("1111:2222:3333:"));
-        assertFalse("IPV6 1111:2222: should be invalid", validator.isValidInet6Address("1111:2222:"));
-        assertFalse("IPV6 :8888 should be invalid", validator.isValidInet6Address(":8888"));
-        assertFalse("IPV6 :7777:8888 should be invalid", validator.isValidInet6Address(":7777:8888"));
-        assertFalse("IPV6 :6666:7777:8888 should be invalid", validator.isValidInet6Address(":6666:7777:8888"));
-        assertFalse("IPV6 :5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":5555:6666:7777:8888"));
-        assertFalse("IPV6 :4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :2222:3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":2222:3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:7777:8888"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:"), "IPV6 1111:2222:3333:4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:"), "IPV6 1111:2222:3333:4444:5555:6666:7777: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:"), "IPV6 1111:2222:3333:4444:5555:6666: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:"), "IPV6 1111:2222:3333:4444:5555: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:"), "IPV6 1111:2222:3333:4444: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:"), "IPV6 1111:2222:3333: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:"), "IPV6 1111:2222: should be invalid");
+        assertFalse(validator.isValidInet6Address(":8888"), "IPV6 :8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":7777:8888"), "IPV6 :7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":6666:7777:8888"), "IPV6 :6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":5555:6666:7777:8888"), "IPV6 :5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":4444:5555:6666:7777:8888"), "IPV6 :4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":3333:4444:5555:6666:7777:8888"), "IPV6 :3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":2222:3333:4444:5555:6666:7777:8888"), "IPV6 :2222:3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:7777:8888"), "IPV6 :1111:2222:3333:4444:5555:6666:7777:8888 should be invalid");
         // :::
-        assertFalse("IPV6 :::2222:3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":::2222:3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:::3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:::3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:::4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:::4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:::5555:6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:::6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:::6666:7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:::7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:::7777:8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:::8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:::8888"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777::: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:::"));
+        assertFalse(validator.isValidInet6Address(":::2222:3333:4444:5555:6666:7777:8888"), "IPV6 :::2222:3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:::3333:4444:5555:6666:7777:8888"), "IPV6 1111:::3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:::4444:5555:6666:7777:8888"), "IPV6 1111:2222:::4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:::5555:6666:7777:8888"), "IPV6 1111:2222:3333:::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:::6666:7777:8888"), "IPV6 1111:2222:3333:4444:::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:::7777:8888"), "IPV6 1111:2222:3333:4444:5555:::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:::8888"), "IPV6 1111:2222:3333:4444:5555:6666:::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:::"), "IPV6 1111:2222:3333:4444:5555:6666:7777::: should be invalid");
         // Double ::
-        assertFalse("IPV6 ::2222::4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("::2222::4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 ::2222:3333::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("::2222:3333::5555:6666:7777:8888"));
-        assertFalse("IPV6 ::2222:3333:4444::6666:7777:8888 should be invalid", validator.isValidInet6Address("::2222:3333:4444::6666:7777:8888"));
-        assertFalse("IPV6 ::2222:3333:4444:5555::7777:8888 should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555::7777:8888"));
-        assertFalse("IPV6 ::2222:3333:4444:5555:7777::8888 should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555:7777::8888"));
-        assertFalse("IPV6 ::2222:3333:4444:5555:7777:8888:: should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555:7777:8888::"));
-        assertFalse("IPV6 1111::3333::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address("1111::3333::5555:6666:7777:8888"));
-        assertFalse("IPV6 1111::3333:4444::6666:7777:8888 should be invalid", validator.isValidInet6Address("1111::3333:4444::6666:7777:8888"));
-        assertFalse("IPV6 1111::3333:4444:5555::7777:8888 should be invalid", validator.isValidInet6Address("1111::3333:4444:5555::7777:8888"));
-        assertFalse("IPV6 1111::3333:4444:5555:6666::8888 should be invalid", validator.isValidInet6Address("1111::3333:4444:5555:6666::8888"));
-        assertFalse("IPV6 1111::3333:4444:5555:6666:7777:: should be invalid", validator.isValidInet6Address("1111::3333:4444:5555:6666:7777::"));
-        assertFalse("IPV6 1111:2222::4444::6666:7777:8888 should be invalid", validator.isValidInet6Address("1111:2222::4444::6666:7777:8888"));
-        assertFalse("IPV6 1111:2222::4444:5555::7777:8888 should be invalid", validator.isValidInet6Address("1111:2222::4444:5555::7777:8888"));
-        assertFalse("IPV6 1111:2222::4444:5555:6666::8888 should be invalid", validator.isValidInet6Address("1111:2222::4444:5555:6666::8888"));
-        assertFalse("IPV6 1111:2222::4444:5555:6666:7777:: should be invalid", validator.isValidInet6Address("1111:2222::4444:5555:6666:7777::"));
-        assertFalse("IPV6 1111:2222:3333::5555::7777:8888 should be invalid", validator.isValidInet6Address("1111:2222:3333::5555::7777:8888"));
-        assertFalse("IPV6 1111:2222:3333::5555:6666::8888 should be invalid", validator.isValidInet6Address("1111:2222:3333::5555:6666::8888"));
-        assertFalse("IPV6 1111:2222:3333::5555:6666:7777:: should be invalid", validator.isValidInet6Address("1111:2222:3333::5555:6666:7777::"));
-        assertFalse("IPV6 1111:2222:3333:4444::6666::8888 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::6666::8888"));
-        assertFalse("IPV6 1111:2222:3333:4444::6666:7777:: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::6666:7777::"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555::7777:: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555::7777::"));
+        assertFalse(validator.isValidInet6Address("::2222::4444:5555:6666:7777:8888"), "IPV6 ::2222::4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333::5555:6666:7777:8888"), "IPV6 ::2222:3333::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444::6666:7777:8888"), "IPV6 ::2222:3333:4444::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555::7777:8888"), "IPV6 ::2222:3333:4444:5555::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555:7777::8888"), "IPV6 ::2222:3333:4444:5555:7777::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555:7777:8888::"), "IPV6 ::2222:3333:4444:5555:7777:8888:: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333::5555:6666:7777:8888"), "IPV6 1111::3333::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444::6666:7777:8888"), "IPV6 1111::3333:4444::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444:5555::7777:8888"), "IPV6 1111::3333:4444:5555::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444:5555:6666::8888"), "IPV6 1111::3333:4444:5555:6666::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444:5555:6666:7777::"), "IPV6 1111::3333:4444:5555:6666:7777:: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444::6666:7777:8888"), "IPV6 1111:2222::4444::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444:5555::7777:8888"), "IPV6 1111:2222::4444:5555::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444:5555:6666::8888"), "IPV6 1111:2222::4444:5555:6666::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444:5555:6666:7777::"), "IPV6 1111:2222::4444:5555:6666:7777:: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555::7777:8888"), "IPV6 1111:2222:3333::5555::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555:6666::8888"), "IPV6 1111:2222:3333::5555:6666::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555:6666:7777::"), "IPV6 1111:2222:3333::5555:6666:7777:: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::6666::8888"), "IPV6 1111:2222:3333:4444::6666::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::6666:7777::"), "IPV6 1111:2222:3333:4444::6666:7777:: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555::7777::"), "IPV6 1111:2222:3333:4444:5555::7777:: should be invalid");
         // Too many components"
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777:8888:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666::1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::1.2.3.4"));
-        assertFalse("IPV6 ::2222:3333:4444:5555:6666:7777:1.2.3.4 should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:1.2.3.4.5 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:1.2.3.4.5"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:8888:1.2.3.4"), "IPV6 1111:2222:3333:4444:5555:6666:7777:8888:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:1.2.3.4"), "IPV6 1111:2222:3333:4444:5555:6666:7777:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::1.2.3.4"), "IPV6 1111:2222:3333:4444:5555:6666::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:1.2.3.4"), "IPV6 ::2222:3333:4444:5555:6666:7777:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:1.2.3.4.5"), "IPV6 1111:2222:3333:4444:5555:6666:1.2.3.4.5 should be invalid");
         // Too few components
-        assertFalse("IPV6 1111:2222:3333:4444:5555:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:1.2.3.4"));
-        assertFalse("IPV6 1111:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:1.2.3.4"));
-        assertFalse("IPV6 1.2.3.4 should be invalid", validator.isValidInet6Address("1.2.3.4"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:1.2.3.4"), "IPV6 1111:2222:3333:4444:5555:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:1.2.3.4"), "IPV6 1111:2222:3333:4444:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:1.2.3.4"), "IPV6 1111:2222:3333:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:1.2.3.4"), "IPV6 1111:2222:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:1.2.3.4"), "IPV6 1111:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1.2.3.4"), "IPV6 1.2.3.4 should be invalid");
         // Missing :
-        assertFalse("IPV6 11112222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("11112222:3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:22223333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:22223333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:33334444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:33334444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:44445555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:44445555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:55556666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:55556666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:66661.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:66661.2.3.4"));
+        assertFalse(validator.isValidInet6Address("11112222:3333:4444:5555:6666:1.2.3.4"), "IPV6 11112222:3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:22223333:4444:5555:6666:1.2.3.4"), "IPV6 1111:22223333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:33334444:5555:6666:1.2.3.4"), "IPV6 1111:2222:33334444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:44445555:6666:1.2.3.4"), "IPV6 1111:2222:3333:44445555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:55556666:1.2.3.4"), "IPV6 1111:2222:3333:4444:55556666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:66661.2.3.4"), "IPV6 1111:2222:3333:4444:5555:66661.2.3.4 should be invalid");
         // Missing .
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:255255.255.255 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255255.255.255"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:255.255255.255 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255.255255.255"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:255.255.255255 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255.255.255255"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255255.255.255"), "IPV6 1111:2222:3333:4444:5555:6666:255255.255.255 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255.255255.255"), "IPV6 1111:2222:3333:4444:5555:6666:255.255255.255 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:255.255.255255"), "IPV6 1111:2222:3333:4444:5555:6666:255.255.255255 should be invalid");
         // Missing : intended for ::
-        assertFalse("IPV6 :1.2.3.4 should be invalid", validator.isValidInet6Address(":1.2.3.4"));
-        assertFalse("IPV6 :6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":6666:1.2.3.4"));
-        assertFalse("IPV6 :5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :2222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":2222:3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:1.2.3.4"));
+        assertFalse(validator.isValidInet6Address(":1.2.3.4"), "IPV6 :1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":6666:1.2.3.4"), "IPV6 :6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":5555:6666:1.2.3.4"), "IPV6 :5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":4444:5555:6666:1.2.3.4"), "IPV6 :4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":3333:4444:5555:6666:1.2.3.4"), "IPV6 :3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":2222:3333:4444:5555:6666:1.2.3.4"), "IPV6 :2222:3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:1.2.3.4"), "IPV6 :1111:2222:3333:4444:5555:6666:1.2.3.4 should be invalid");
         // :::
-        assertFalse("IPV6 :::2222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":::2222:3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:::3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:::3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:::4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:::4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:::6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:::6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:::1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:::1.2.3.4"));
+        assertFalse(validator.isValidInet6Address(":::2222:3333:4444:5555:6666:1.2.3.4"), "IPV6 :::2222:3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:::3333:4444:5555:6666:1.2.3.4"), "IPV6 1111:::3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:::4444:5555:6666:1.2.3.4"), "IPV6 1111:2222:::4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:::5555:6666:1.2.3.4"), "IPV6 1111:2222:3333:::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:::6666:1.2.3.4"), "IPV6 1111:2222:3333:4444:::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:::1.2.3.4"), "IPV6 1111:2222:3333:4444:5555:::1.2.3.4 should be invalid");
         // Double ::
-        assertFalse("IPV6 ::2222::4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("::2222::4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 ::2222:3333::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("::2222:3333::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 ::2222:3333:4444::6666:1.2.3.4 should be invalid", validator.isValidInet6Address("::2222:3333:4444::6666:1.2.3.4"));
-        assertFalse("IPV6 ::2222:3333:4444:5555::1.2.3.4 should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555::1.2.3.4"));
-        assertFalse("IPV6 1111::3333::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111::3333::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 1111::3333:4444::6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111::3333:4444::6666:1.2.3.4"));
-        assertFalse("IPV6 1111::3333:4444:5555::1.2.3.4 should be invalid", validator.isValidInet6Address("1111::3333:4444:5555::1.2.3.4"));
-        assertFalse("IPV6 1111:2222::4444::6666:1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222::4444::6666:1.2.3.4"));
-        assertFalse("IPV6 1111:2222::4444:5555::1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222::4444:5555::1.2.3.4"));
-        assertFalse("IPV6 1111:2222:3333::5555::1.2.3.4 should be invalid", validator.isValidInet6Address("1111:2222:3333::5555::1.2.3.4"));
+        assertFalse(validator.isValidInet6Address("::2222::4444:5555:6666:1.2.3.4"), "IPV6 ::2222::4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333::5555:6666:1.2.3.4"), "IPV6 ::2222:3333::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444::6666:1.2.3.4"), "IPV6 ::2222:3333:4444::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555::1.2.3.4"), "IPV6 ::2222:3333:4444:5555::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333::5555:6666:1.2.3.4"), "IPV6 1111::3333::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444::6666:1.2.3.4"), "IPV6 1111::3333:4444::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444:5555::1.2.3.4"), "IPV6 1111::3333:4444:5555::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444::6666:1.2.3.4"), "IPV6 1111:2222::4444::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444:5555::1.2.3.4"), "IPV6 1111:2222::4444:5555::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555::1.2.3.4"), "IPV6 1111:2222:3333::5555::1.2.3.4 should be invalid");
         // Missing parts
-        assertFalse("IPV6 ::. should be invalid", validator.isValidInet6Address("::."));
-        assertFalse("IPV6 ::.. should be invalid", validator.isValidInet6Address("::.."));
-        assertFalse("IPV6 ::... should be invalid", validator.isValidInet6Address("::..."));
-        assertFalse("IPV6 ::1... should be invalid", validator.isValidInet6Address("::1..."));
-        assertFalse("IPV6 ::1.2.. should be invalid", validator.isValidInet6Address("::1.2.."));
-        assertFalse("IPV6 ::1.2.3. should be invalid", validator.isValidInet6Address("::1.2.3."));
-        assertFalse("IPV6 ::.2.. should be invalid", validator.isValidInet6Address("::.2.."));
-        assertFalse("IPV6 ::.2.3. should be invalid", validator.isValidInet6Address("::.2.3."));
-        assertFalse("IPV6 ::.2.3.4 should be invalid", validator.isValidInet6Address("::.2.3.4"));
-        assertFalse("IPV6 ::..3. should be invalid", validator.isValidInet6Address("::..3."));
-        assertFalse("IPV6 ::..3.4 should be invalid", validator.isValidInet6Address("::..3.4"));
-        assertFalse("IPV6 ::...4 should be invalid", validator.isValidInet6Address("::...4"));
+        assertFalse(validator.isValidInet6Address("::."), "IPV6 ::. should be invalid");
+        assertFalse(validator.isValidInet6Address("::.."), "IPV6 ::.. should be invalid");
+        assertFalse(validator.isValidInet6Address("::..."), "IPV6 ::... should be invalid");
+        assertFalse(validator.isValidInet6Address("::1..."), "IPV6 ::1... should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.."), "IPV6 ::1.2.. should be invalid");
+        assertFalse(validator.isValidInet6Address("::1.2.3."), "IPV6 ::1.2.3. should be invalid");
+        assertFalse(validator.isValidInet6Address("::.2.."), "IPV6 ::.2.. should be invalid");
+        assertFalse(validator.isValidInet6Address("::.2.3."), "IPV6 ::.2.3. should be invalid");
+        assertFalse(validator.isValidInet6Address("::.2.3.4"), "IPV6 ::.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::..3."), "IPV6 ::..3. should be invalid");
+        assertFalse(validator.isValidInet6Address("::..3.4"), "IPV6 ::..3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address("::...4"), "IPV6 ::...4 should be invalid");
         // Extra : in front
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666:7777:: should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:7777::"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666:: should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666::"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:: should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555::"));
-        assertFalse("IPV6 :1111:2222:3333:4444:: should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::"));
-        assertFalse("IPV6 :1111:2222:3333:: should be invalid", validator.isValidInet6Address(":1111:2222:3333::"));
-        assertFalse("IPV6 :1111:2222:: should be invalid", validator.isValidInet6Address(":1111:2222::"));
-        assertFalse("IPV6 :1111:: should be invalid", validator.isValidInet6Address(":1111::"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666::8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666::8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555::8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555::8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444::8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::8888"));
-        assertFalse("IPV6 :1111:2222:3333::8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333::8888"));
-        assertFalse("IPV6 :1111:2222::8888 should be invalid", validator.isValidInet6Address(":1111:2222::8888"));
-        assertFalse("IPV6 :1111::8888 should be invalid", validator.isValidInet6Address(":1111::8888"));
-        assertFalse("IPV6 :::8888 should be invalid", validator.isValidInet6Address(":::8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555::7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555::7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444::7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333::7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333::7777:8888"));
-        assertFalse("IPV6 :1111:2222::7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222::7777:8888"));
-        assertFalse("IPV6 :1111::7777:8888 should be invalid", validator.isValidInet6Address(":1111::7777:8888"));
-        assertFalse("IPV6 :::7777:8888 should be invalid", validator.isValidInet6Address(":::7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444::6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333::6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333::6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222::6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222::6666:7777:8888"));
-        assertFalse("IPV6 :1111::6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111::6666:7777:8888"));
-        assertFalse("IPV6 :::6666:7777:8888 should be invalid", validator.isValidInet6Address(":::6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222:3333::5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222::5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111::5555:6666:7777:8888"));
-        assertFalse("IPV6 :::5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":::5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222::4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111:2222::4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111::4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111::4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :::4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":::4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111::3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":1111::3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :::3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":::3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :::2222:3333:4444:5555:6666:7777:8888 should be invalid", validator.isValidInet6Address(":::2222:3333:4444:5555:6666:7777:8888"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333:4444:5555::1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444:5555::1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333:4444::1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333::1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333::1.2.3.4"));
-        assertFalse("IPV6 :1111:2222::1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222::1.2.3.4"));
-        assertFalse("IPV6 :1111::1.2.3.4 should be invalid", validator.isValidInet6Address(":1111::1.2.3.4"));
-        assertFalse("IPV6 :::1.2.3.4 should be invalid", validator.isValidInet6Address(":::1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333:4444::6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333:4444::6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333::6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333::6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222::6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222::6666:1.2.3.4"));
-        assertFalse("IPV6 :1111::6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111::6666:1.2.3.4"));
-        assertFalse("IPV6 :::6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":::6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222:3333::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222:3333::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :::5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":::5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111:2222::4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111:2222::4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111::4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111::4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :::4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":::4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :1111::3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":1111::3333:4444:5555:6666:1.2.3.4"));
-        assertFalse("IPV6 :::2222:3333:4444:5555:6666:1.2.3.4 should be invalid", validator.isValidInet6Address(":::2222:3333:4444:5555:6666:1.2.3.4"));
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:7777::"), "IPV6 :1111:2222:3333:4444:5555:6666:7777:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666::"), "IPV6 :1111:2222:3333:4444:5555:6666:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555::"), "IPV6 :1111:2222:3333:4444:5555:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::"), "IPV6 :1111:2222:3333:4444:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::"), "IPV6 :1111:2222:3333:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::"), "IPV6 :1111:2222:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::"), "IPV6 :1111:: should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666::8888"), "IPV6 :1111:2222:3333:4444:5555:6666::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555::8888"), "IPV6 :1111:2222:3333:4444:5555::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::8888"), "IPV6 :1111:2222:3333:4444::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::8888"), "IPV6 :1111:2222:3333::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::8888"), "IPV6 :1111:2222::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::8888"), "IPV6 :1111::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::8888"), "IPV6 :::8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555::7777:8888"), "IPV6 :1111:2222:3333:4444:5555::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::7777:8888"), "IPV6 :1111:2222:3333:4444::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::7777:8888"), "IPV6 :1111:2222:3333::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::7777:8888"), "IPV6 :1111:2222::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::7777:8888"), "IPV6 :1111::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::7777:8888"), "IPV6 :::7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::6666:7777:8888"), "IPV6 :1111:2222:3333:4444::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::6666:7777:8888"), "IPV6 :1111:2222:3333::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::6666:7777:8888"), "IPV6 :1111:2222::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::6666:7777:8888"), "IPV6 :1111::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::6666:7777:8888"), "IPV6 :::6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::5555:6666:7777:8888"), "IPV6 :1111:2222:3333::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::5555:6666:7777:8888"), "IPV6 :1111:2222::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::5555:6666:7777:8888"), "IPV6 :1111::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::5555:6666:7777:8888"), "IPV6 :::5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::4444:5555:6666:7777:8888"), "IPV6 :1111:2222::4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::4444:5555:6666:7777:8888"), "IPV6 :1111::4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::4444:5555:6666:7777:8888"), "IPV6 :::4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::3333:4444:5555:6666:7777:8888"), "IPV6 :1111::3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::3333:4444:5555:6666:7777:8888"), "IPV6 :::3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::2222:3333:4444:5555:6666:7777:8888"), "IPV6 :::2222:3333:4444:5555:6666:7777:8888 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555:6666:1.2.3.4"), "IPV6 :1111:2222:3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444:5555::1.2.3.4"), "IPV6 :1111:2222:3333:4444:5555::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::1.2.3.4"), "IPV6 :1111:2222:3333:4444::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::1.2.3.4"), "IPV6 :1111:2222:3333::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::1.2.3.4"), "IPV6 :1111:2222::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::1.2.3.4"), "IPV6 :1111::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::1.2.3.4"), "IPV6 :::1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333:4444::6666:1.2.3.4"), "IPV6 :1111:2222:3333:4444::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::6666:1.2.3.4"), "IPV6 :1111:2222:3333::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::6666:1.2.3.4"), "IPV6 :1111:2222::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::6666:1.2.3.4"), "IPV6 :1111::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::6666:1.2.3.4"), "IPV6 :::6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222:3333::5555:6666:1.2.3.4"), "IPV6 :1111:2222:3333::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::5555:6666:1.2.3.4"), "IPV6 :1111:2222::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::5555:6666:1.2.3.4"), "IPV6 :1111::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::5555:6666:1.2.3.4"), "IPV6 :::5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111:2222::4444:5555:6666:1.2.3.4"), "IPV6 :1111:2222::4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::4444:5555:6666:1.2.3.4"), "IPV6 :1111::4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::4444:5555:6666:1.2.3.4"), "IPV6 :::4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":1111::3333:4444:5555:6666:1.2.3.4"), "IPV6 :1111::3333:4444:5555:6666:1.2.3.4 should be invalid");
+        assertFalse(validator.isValidInet6Address(":::2222:3333:4444:5555:6666:1.2.3.4"), "IPV6 :::2222:3333:4444:5555:6666:1.2.3.4 should be invalid");
         // Extra : at end
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666:7777::: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:::"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666::: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:::"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555::: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:::"));
-        assertFalse("IPV6 1111:2222:3333:4444::: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:::"));
-        assertFalse("IPV6 1111:2222:3333::: should be invalid", validator.isValidInet6Address("1111:2222:3333:::"));
-        assertFalse("IPV6 1111:2222::: should be invalid", validator.isValidInet6Address("1111:2222:::"));
-        assertFalse("IPV6 1111::: should be invalid", validator.isValidInet6Address("1111:::"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555:6666::8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555::8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555::8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444::8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::8888:"));
-        assertFalse("IPV6 1111:2222:3333::8888: should be invalid", validator.isValidInet6Address("1111:2222:3333::8888:"));
-        assertFalse("IPV6 1111:2222::8888: should be invalid", validator.isValidInet6Address("1111:2222::8888:"));
-        assertFalse("IPV6 1111::8888: should be invalid", validator.isValidInet6Address("1111::8888:"));
-        assertFalse("IPV6 ::8888: should be invalid", validator.isValidInet6Address("::8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444:5555::7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444:5555::7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444::7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333::7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333::7777:8888:"));
-        assertFalse("IPV6 1111:2222::7777:8888: should be invalid", validator.isValidInet6Address("1111:2222::7777:8888:"));
-        assertFalse("IPV6 1111::7777:8888: should be invalid", validator.isValidInet6Address("1111::7777:8888:"));
-        assertFalse("IPV6 ::7777:8888: should be invalid", validator.isValidInet6Address("::7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333:4444::6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333:4444::6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333::6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333::6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222::6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222::6666:7777:8888:"));
-        assertFalse("IPV6 1111::6666:7777:8888: should be invalid", validator.isValidInet6Address("1111::6666:7777:8888:"));
-        assertFalse("IPV6 ::6666:7777:8888: should be invalid", validator.isValidInet6Address("::6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222:3333::5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222:3333::5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222::5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222::5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111::5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111::5555:6666:7777:8888:"));
-        assertFalse("IPV6 ::5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("::5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111:2222::4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111:2222::4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111::4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111::4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 ::4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("::4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 1111::3333:4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("1111::3333:4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 ::3333:4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("::3333:4444:5555:6666:7777:8888:"));
-        assertFalse("IPV6 ::2222:3333:4444:5555:6666:7777:8888: should be invalid", validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888:"));
-        assertTrue("IPV6 0:a:b:c:d:e:f:: should be valid", validator.isValidInet6Address("0:a:b:c:d:e:f::"));
-        assertTrue("IPV6 ::0:a:b:c:d:e:f should be valid", validator.isValidInet6Address("::0:a:b:c:d:e:f")); // syntactically correct, but bad form (::0:... could be combined)
-        assertTrue("IPV6 a:b:c:d:e:f:0:: should be valid", validator.isValidInet6Address("a:b:c:d:e:f:0::"));
-        assertFalse("IPV6 ':10.0.0.1 should be invalid", validator.isValidInet6Address("':10.0.0.1"));
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:7777:::"), "IPV6 1111:2222:3333:4444:5555:6666:7777::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666:::"), "IPV6 1111:2222:3333:4444:5555:6666::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:::"), "IPV6 1111:2222:3333:4444:5555::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:::"), "IPV6 1111:2222:3333:4444::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:::"), "IPV6 1111:2222:3333::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:::"), "IPV6 1111:2222::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:::"), "IPV6 1111::: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555:6666::8888:"), "IPV6 1111:2222:3333:4444:5555:6666::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555::8888:"), "IPV6 1111:2222:3333:4444:5555::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::8888:"), "IPV6 1111:2222:3333:4444::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::8888:"), "IPV6 1111:2222:3333::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::8888:"), "IPV6 1111:2222::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::8888:"), "IPV6 1111::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::8888:"), "IPV6 ::8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444:5555::7777:8888:"), "IPV6 1111:2222:3333:4444:5555::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::7777:8888:"), "IPV6 1111:2222:3333:4444::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::7777:8888:"), "IPV6 1111:2222:3333::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::7777:8888:"), "IPV6 1111:2222::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::7777:8888:"), "IPV6 1111::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::7777:8888:"), "IPV6 ::7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333:4444::6666:7777:8888:"), "IPV6 1111:2222:3333:4444::6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::6666:7777:8888:"), "IPV6 1111:2222:3333::6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::6666:7777:8888:"), "IPV6 1111:2222::6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::6666:7777:8888:"), "IPV6 1111::6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::6666:7777:8888:"), "IPV6 ::6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222:3333::5555:6666:7777:8888:"), "IPV6 1111:2222:3333::5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::5555:6666:7777:8888:"), "IPV6 1111:2222::5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::5555:6666:7777:8888:"), "IPV6 1111::5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::5555:6666:7777:8888:"), "IPV6 ::5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111:2222::4444:5555:6666:7777:8888:"), "IPV6 1111:2222::4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::4444:5555:6666:7777:8888:"), "IPV6 1111::4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::4444:5555:6666:7777:8888:"), "IPV6 ::4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("1111::3333:4444:5555:6666:7777:8888:"), "IPV6 1111::3333:4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::3333:4444:5555:6666:7777:8888:"), "IPV6 ::3333:4444:5555:6666:7777:8888: should be invalid");
+        assertFalse(validator.isValidInet6Address("::2222:3333:4444:5555:6666:7777:8888:"), "IPV6 ::2222:3333:4444:5555:6666:7777:8888: should be invalid");
+        assertTrue(validator.isValidInet6Address("0:a:b:c:d:e:f::"), "IPV6 0:a:b:c:d:e:f:: should be valid");
+        assertTrue(validator.isValidInet6Address("::0:a:b:c:d:e:f"), "IPV6 ::0:a:b:c:d:e:f should be valid"); // syntactically correct, but bad form (::0:... could be combined)
+        assertTrue(validator.isValidInet6Address("a:b:c:d:e:f:0::"), "IPV6 a:b:c:d:e:f:0:: should be valid");
+        assertFalse(validator.isValidInet6Address("':10.0.0.1"), "IPV6 ':10.0.0.1 should be invalid");
     }
     // CHECKSTYLE.ON: ExecutableStatementCount
     // CHECKSTYLE.ON: MethodLengthCheck

test/unit/org/openstreetmap/josm/data/validation/routines/RegexValidatorTest.java

@@ -16 +16 @@
  */
 package org.openstreetmap.josm.data.validation.routines;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-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.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import java.util.Arrays;
@@ -59 +59 @@
         RegexValidator insensitive = new RegexValidator(REGEX, false);
 
         // isValid()
-        assertTrue("Sensitive isValid() valid",      sensitive.isValid("ac-DE-1"));
-        assertFalse("Sensitive isValid() invalid",   sensitive.isValid("AB-de-1"));
-        assertTrue("Insensitive isValid() valid",    insensitive.isValid("AB-de-1"));
-        assertFalse("Insensitive isValid() invalid", insensitive.isValid("ABd-de-1"));
+        assertTrue(sensitive.isValid("ac-DE-1"), "Sensitive isValid() valid");
+        assertFalse(sensitive.isValid("AB-de-1"), "Sensitive isValid() invalid");
+        assertTrue(insensitive.isValid("AB-de-1"), "Insensitive isValid() valid");
+        assertFalse(insensitive.isValid("ABd-de-1"), "Insensitive isValid() invalid");
 
         // validate()
-        assertEquals("Sensitive validate() valid",   "acDE1", sensitive.validate("ac-DE-1"));
-        assertNull("Sensitive validate() invalid",   sensitive.validate("AB-de-1"));
-        assertEquals("Insensitive validate() valid", "ABde1", insensitive.validate("AB-de-1"));
-        assertNull("Insensitive validate() invalid", insensitive.validate("ABd-de-1"));
+        assertEquals("acDE1", sensitive.validate("ac-DE-1"), "Sensitive validate() valid");
+        assertNull(sensitive.validate("AB-de-1"), "Sensitive validate() invalid");
+        assertEquals("ABde1", insensitive.validate("AB-de-1"), "Insensitive validate() valid");
+        assertNull(insensitive.validate("ABd-de-1"), "Insensitive validate() invalid");
 
         // match()
         checkArray("Sensitive match() valid",     new String[] {"ac", "DE", "1"}, sensitive.match("ac-DE-1"));
         checkArray("Sensitive match() invalid",   null,                           sensitive.match("AB-de-1"));
         checkArray("Insensitive match() valid",   new String[] {"AB", "de", "1"}, insensitive.match("AB-de-1"));
         checkArray("Insensitive match() invalid", null,                           insensitive.match("ABd-de-1"));
-        assertEquals("validate one", "ABC", (new RegexValidator("^([A-Z]*)$")).validate("ABC"));
+        assertEquals("ABC", (new RegexValidator("^([A-Z]*)$")).validate("ABC"), "validate one");
         checkArray("match one", new String[] {"ABC"}, (new RegexValidator("^([A-Z]*)$")).match("ABC"));
     }
 
@@ -97 +97 @@
         String[] array = new String[] {"aac", "FDE", "321"};
 
         // isValid()
-        assertTrue("Sensitive isValid() Multiple", multiple.isValid(value));
-        assertFalse("Sensitive isValid() 1st",     single1.isValid(value));
-        assertTrue("Sensitive isValid() 2nd",      single2.isValid(value));
-        assertFalse("Sensitive isValid() 3rd",     single3.isValid(value));
+        assertTrue(multiple.isValid(value), "Sensitive isValid() Multiple");
+        assertFalse(single1.isValid(value), "Sensitive isValid() 1st");
+        assertTrue(single2.isValid(value), "Sensitive isValid() 2nd");
+        assertFalse(single3.isValid(value), "Sensitive isValid() 3rd");
 
         // validate()
-        assertEquals("Sensitive validate() Multiple", expect, multiple.validate(value));
-        assertNull("Sensitive validate() 1st",        single1.validate(value));
-        assertEquals("Sensitive validate() 2nd",      expect, single2.validate(value));
-        assertNull("Sensitive validate() 3rd",        single3.validate(value));
+        assertEquals(expect, multiple.validate(value), "Sensitive validate() Multiple");
+        assertNull(single1.validate(value), "Sensitive validate() 1st");
+        assertEquals(expect, single2.validate(value), "Sensitive validate() 2nd");
+        assertNull(single3.validate(value), "Sensitive validate() 3rd");
 
         // match()
         checkArray("Sensitive match() Multiple", array, multiple.match(value));
@@ -116 +116 @@
 
         // All invalid
         value = "AAC*FDE*321";
-        assertFalse("isValid() Invalid", multiple.isValid(value));
-        assertNull("validate() Invalid", multiple.validate(value));
-        assertNull("match() Multiple",   multiple.match(value));
+        assertFalse(multiple.isValid(value), "isValid() Invalid");
+        assertNull(multiple.validate(value), "validate() Invalid");
+        assertNull(multiple.match(value), "match() Multiple");
     }
 
     /**
@@ -139 +139 @@
         String[] array = new String[] {"AAC", "FDE", "321"};
 
         // isValid()
-        assertTrue("isValid() Multiple", multiple.isValid(value));
-        assertFalse("isValid() 1st",     single1.isValid(value));
-        assertTrue("isValid() 2nd",      single2.isValid(value));
-        assertFalse("isValid() 3rd",     single3.isValid(value));
+        assertTrue(multiple.isValid(value), "isValid() Multiple");
+        assertFalse(single1.isValid(value), "isValid() 1st");
+        assertTrue(single2.isValid(value), "isValid() 2nd");
+        assertFalse(single3.isValid(value), "isValid() 3rd");
 
         // validate()
-        assertEquals("validate() Multiple", expect, multiple.validate(value));
-        assertNull("validate() 1st",        single1.validate(value));
-        assertEquals("validate() 2nd",      expect, single2.validate(value));
-        assertNull("validate() 3rd",        single3.validate(value));
+        assertEquals(expect, multiple.validate(value), "validate() Multiple");
+        assertNull(single1.validate(value), "validate() 1st");
+        assertEquals(expect, single2.validate(value), "validate() 2nd");
+        assertNull(single3.validate(value), "validate() 3rd");
 
         // match()
         checkArray("match() Multiple", array, multiple.match(value));
@@ -158 +158 @@
 
         // All invalid
         value = "AAC*FDE*321";
-        assertFalse("isValid() Invalid", multiple.isValid(value));
-        assertNull("validate() Invalid", multiple.validate(value));
-        assertNull("match() Multiple",   multiple.match(value));
+        assertFalse(multiple.isValid(value), "isValid() Invalid");
+        assertNull(multiple.validate(value), "validate() Invalid");
+        assertNull(multiple.match(value), "match() Multiple");
     }
 
     /**
@@ -169 +169 @@
     @Test
     void testNullValue() {
         RegexValidator validator = new RegexValidator(REGEX);
-        assertFalse("Instance isValid()", validator.isValid(null));
-        assertNull("Instance validate()", validator.validate(null));
-        assertNull("Instance match()",    validator.match(null));
+        assertFalse(validator.isValid(null), "Instance isValid()");
+        assertNull(validator.validate(null), "Instance validate()");
+        assertNull(validator.match(null), "Instance match()");
     }
 
     // CHECKSTYLE.ON: SingleSpaceSeparator
@@ -187 +187 @@
             new RegexValidator((String) null);
             fail("Single Null - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Single Null", "Regular expression[0] is missing", e.getMessage());
+            assertEquals("Regular expression[0] is missing", e.getMessage(), "Single Null");
         }
 
         // Single Regular Expression - Zero Length
@@ -195 +195 @@
             new RegexValidator("");
             fail("Single Zero Length - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Single Zero Length", "Regular expression[0] is missing", e.getMessage());
+            assertEquals("Regular expression[0] is missing", e.getMessage(), "Single Zero Length");
         }
 
         // Multiple Regular Expression - Null array
@@ -203 +203 @@
             new RegexValidator((String[]) null);
             fail("Null Array - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Null Array", "Regular expressions are missing", e.getMessage());
+            assertEquals("Regular expressions are missing", e.getMessage(), "Null Array");
         }
 
         // Multiple Regular Expression - Zero Length array
@@ -211 +211 @@
             new RegexValidator(new String[0]);
             fail("Zero Length Array - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Zero Length Array", "Regular expressions are missing", e.getMessage());
+            assertEquals("Regular expressions are missing", e.getMessage(), "Zero Length Array");
         }
 
         // Multiple Regular Expression - Array has Null
@@ -220 +220 @@
             new RegexValidator(expressions);
             fail("Array has Null - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Array has Null", "Regular expression[1] is missing", e.getMessage());
+            assertEquals("Regular expression[1] is missing", e.getMessage(), "Array has Null");
         }
 
         // Multiple Regular Expression - Array has Zero Length
@@ -229 +229 @@
             new RegexValidator(expressions);
             fail("Array has Zero Length - expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
-            assertEquals("Array has Zero Length", "Regular expression[0] is missing", e.getMessage());
+            assertEquals("Regular expression[0] is missing", e.getMessage(), "Array has Zero Length");
         }
     }
 
@@ -253 +253 @@
     @Test
     void testToString() {
         RegexValidator single = new RegexValidator(REGEX);
-        assertEquals("Single", "RegexValidator{" + REGEX + "}", single.toString());
+        assertEquals("RegexValidator{" + REGEX + "}", single.toString(), "Single");
 
         RegexValidator multiple = new RegexValidator(new String[] {REGEX, REGEX});
-        assertEquals("Multiple", "RegexValidator{" + REGEX + "," + REGEX + "}", multiple.toString());
+        assertEquals("RegexValidator{" + REGEX + "," + REGEX + "}", multiple.toString(), "Multiple");
     }
 
     /**
@@ -292 +292 @@
 
         // Check Values
         for (int i = 0; i < expect.length; i++) {
-            assertEquals(label +" value[" + i + "]", expect[i], result[i]);
+            assertEquals(expect[i], result[i], label +" value[" + i + "]");
         }
     }
 }

test/unit/org/openstreetmap/josm/data/validation/routines/UrlValidatorTest.java

@@ -16 +16 @@
  */
 package org.openstreetmap.josm.data.validation.routines;
 
-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.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -70 +70 @@
         UrlValidator urlVal = new UrlValidator(schemes, 0);
         for (ResultPair testPair : testScheme) {
             boolean result = urlVal.isValidScheme(testPair.item);
-            assertEquals(testPair.item, testPair.valid, result);
+            assertEquals(testPair.valid, result, testPair.item);
             if (printStatus) {
                 if (result == testPair.valid) {
                     System.out.print('.');
@@ -111 +111 @@
             }
             String url = testBuffer.toString();
             boolean result = urlVal.isValid(url);
-            assertEquals(url, expected, result);
+            assertEquals(expected, result, url);
             if (printStatus) {
                 if (printIndex) {
                     System.out.print(testPartsIndextoString());
@@ -163 +163 @@
     @Test
     void testValidator218() {
         UrlValidator validator = new UrlValidator(UrlValidator.ALLOW_2_SLASHES);
-        assertTrue("parentheses should be valid in URLs",
-                validator.isValid("http://somewhere.com/pathxyz/file(1).html"));
+        assertTrue(validator.isValid("http://somewhere.com/pathxyz/file(1).html"), "parentheses should be valid in URLs");
     }
 
     /**
@@ -178 +177 @@
             return; // Cannot run the test
         }
         UrlValidator validator = new UrlValidator();
-        assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("http://xn--d1abbgf6aiiy.xn--p1ai"));
-        assertTrue("президент.рф should validate", validator.isValid("http://президент.рф"));
-        assertTrue("www.b\u00fccher.ch should validate", validator.isValid("http://www.b\u00fccher.ch"));
-        assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("http://www.\uFFFD.ch"));
-        assertTrue("www.b\u00fccher.ch should validate", validator.isValid("ftp://www.b\u00fccher.ch"));
-        assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("ftp://www.\uFFFD.ch"));
+        assertTrue(validator.isValid("http://xn--d1abbgf6aiiy.xn--p1ai"), "xn--d1abbgf6aiiy.xn--p1ai should validate");
+        assertTrue(validator.isValid("http://президент.рф"), "президент.рф should validate");
+        assertTrue(validator.isValid("http://www.b\u00fccher.ch"), "www.b\u00fccher.ch should validate");
+        assertFalse(validator.isValid("http://www.\uFFFD.ch"), "www.\uFFFD.ch FFFD should fail");
+        assertTrue(validator.isValid("ftp://www.b\u00fccher.ch"), "www.b\u00fccher.ch should validate");
+        assertFalse(validator.isValid("ftp://www.\uFFFD.ch"), "www.\uFFFD.ch FFFD should fail");
     }
 
     /**
@@ -194 +193 @@
         RegexValidator regex = new RegexValidator("localhost", ".*\\.my-testing");
         UrlValidator validator = new UrlValidator(regex, 0);
 
-        assertTrue("localhost URL should validate",
-                validator.isValid("http://localhost/test/index.html"));
-        assertTrue("first.my-testing should validate",
-                validator.isValid("http://first.my-testing/test/index.html"));
-        assertTrue("sup3r.my-testing should validate",
-                validator.isValid("http://sup3r.my-testing/test/index.html"));
+        assertTrue(validator.isValid("http://localhost/test/index.html"), "localhost URL should validate");
+        assertTrue(validator.isValid("http://first.my-testing/test/index.html"), "first.my-testing should validate");
+        assertTrue(validator.isValid("http://sup3r.my-testing/test/index.html"), "sup3r.my-testing should validate");
 
-        assertFalse("broke.my-test should not validate",
-                validator.isValid("http://broke.my-test/test/index.html"));
+        assertFalse(validator.isValid("http://broke.my-test/test/index.html"), "broke.my-test should not validate");
 
-        assertTrue("www.apache.org should still validate",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "www.apache.org should still validate");
 
         // Now check using options
         validator = new UrlValidator(UrlValidator.ALLOW_LOCAL_URLS);
 
-        assertTrue("localhost URL should validate",
-                validator.isValid("http://localhost/test/index.html"));
+        assertTrue(validator.isValid("http://localhost/test/index.html"), "localhost URL should validate");
 
-        assertTrue("machinename URL should validate",
-                validator.isValid("http://machinename/test/index.html"));
+        assertTrue(validator.isValid("http://machinename/test/index.html"), "machinename URL should validate");
 
-        assertTrue("www.apache.org should still validate",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "www.apache.org should still validate");
     }
 
     /**
@@ -227 +218 @@
     void testValidator288() {
         UrlValidator validator = new UrlValidator(UrlValidator.ALLOW_LOCAL_URLS);
 
-        assertTrue("hostname should validate",
-                validator.isValid("http://hostname"));
+        assertTrue(validator.isValid("http://hostname"), "hostname should validate");
 
-        assertTrue("hostname with path should validate",
-                validator.isValid("http://hostname/test/index.html"));
+        assertTrue(validator.isValid("http://hostname/test/index.html"), "hostname with path should validate");
 
-        assertTrue("localhost URL should validate",
-                validator.isValid("http://localhost/test/index.html"));
+        assertTrue(validator.isValid("http://localhost/test/index.html"), "localhost URL should validate");
 
-        assertFalse("first.my-testing should not validate",
-                validator.isValid("http://first.my-testing/test/index.html"));
+        assertFalse(validator.isValid("http://first.my-testing/test/index.html"), "first.my-testing should not validate");
 
-        assertFalse("broke.hostname should not validate",
-                validator.isValid("http://broke.hostname/test/index.html"));
+        assertFalse(validator.isValid("http://broke.hostname/test/index.html"), "broke.hostname should not validate");
 
-        assertTrue("www.apache.org should still validate",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "www.apache.org should still validate");
 
         // Turn it off, and check
         validator = new UrlValidator(0);
 
-        assertFalse("hostname should no longer validate",
-                validator.isValid("http://hostname"));
+        assertFalse(validator.isValid("http://hostname"), "hostname should no longer validate");
 
-        assertFalse("localhost URL should no longer validate",
-                validator.isValid("http://localhost/test/index.html"));
+        assertFalse(validator.isValid("http://localhost/test/index.html"), "localhost URL should no longer validate");
 
-        assertTrue("www.apache.org should still validate",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "www.apache.org should still validate");
     }
 
     /**
@@ -266 +248 @@
         // file:// isn't allowed by default
         UrlValidator validator = new UrlValidator();
 
-        assertTrue("http://apache.org/ should be allowed by default",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "http://apache.org/ should be allowed by default");
 
-        assertFalse("file:///c:/ shouldn't be allowed by default",
-                validator.isValid("file:///C:/some.file"));
+        assertFalse(validator.isValid("file:///C:/some.file"), "file:///c:/ shouldn't be allowed by default");
 
-        assertFalse("file:///c:\\ shouldn't be allowed by default",
-                validator.isValid("file:///C:\\some.file"));
+        assertFalse(validator.isValid("file:///C:\\some.file"), "file:///c:\\ shouldn't be allowed by default");
 
-        assertFalse("file:///etc/ shouldn't be allowed by default",
-                validator.isValid("file:///etc/hosts"));
+        assertFalse(validator.isValid("file:///etc/hosts"), "file:///etc/ shouldn't be allowed by default");
 
-        assertFalse("file://localhost/etc/ shouldn't be allowed by default",
-                validator.isValid("file://localhost/etc/hosts"));
+        assertFalse(validator.isValid("file://localhost/etc/hosts"), "file://localhost/etc/ shouldn't be allowed by default");
 
-        assertFalse("file://localhost/c:/ shouldn't be allowed by default",
-                validator.isValid("file://localhost/c:/some.file"));
+        assertFalse(validator.isValid("file://localhost/c:/some.file"), "file://localhost/c:/ shouldn't be allowed by default");
 
         // Turn it on, and check
         // Note - we need to enable local urls when working with file:
         validator = new UrlValidator(new String[]{"http", "file"}, UrlValidator.ALLOW_LOCAL_URLS);
 
-        assertTrue("http://apache.org/ should be allowed by default",
-                validator.isValid("http://www.apache.org/test/index.html"));
+        assertTrue(validator.isValid("http://www.apache.org/test/index.html"), "http://apache.org/ should be allowed by default");
 
-        assertTrue("file:///c:/ should now be allowed",
-                validator.isValid("file:///C:/some.file"));
+        assertTrue(validator.isValid("file:///C:/some.file"), "file:///c:/ should now be allowed");
 
         // Currently, we don't support the c:\ form
-        assertFalse("file:///c:\\ shouldn't be allowed",
-                validator.isValid("file:///C:\\some.file"));
+        assertFalse(validator.isValid("file:///C:\\some.file"), "file:///c:\\ shouldn't be allowed");
 
-        assertTrue("file:///etc/ should now be allowed",
-                validator.isValid("file:///etc/hosts"));
+        assertTrue(validator.isValid("file:///etc/hosts"), "file:///etc/ should now be allowed");
 
-        assertTrue("file://localhost/etc/ should now be allowed",
-                validator.isValid("file://localhost/etc/hosts"));
+        assertTrue(validator.isValid("file://localhost/etc/hosts"), "file://localhost/etc/ should now be allowed");
 
-        assertTrue("file://localhost/c:/ should now be allowed",
-                validator.isValid("file://localhost/c:/some.file"));
+        assertTrue(validator.isValid("file://localhost/c:/some.file"), "file://localhost/c:/ should now be allowed");
 
         // These are never valid
-        assertFalse("file://c:/ shouldn't ever be allowed, needs file:///c:/",
-                validator.isValid("file://C:/some.file"));
+        assertFalse(validator.isValid("file://C:/some.file"), "file://c:/ shouldn't ever be allowed, needs file:///c:/");
 
-        assertFalse("file://c:\\ shouldn't ever be allowed, needs file:///c:/",
-                validator.isValid("file://C:\\some.file"));
+        assertFalse(validator.isValid("file://C:\\some.file"), "file://c:\\ shouldn't ever be allowed, needs file:///c:/");
     }
 
     /**
@@ -482 +450 @@
     public void testValidator375() {
         UrlValidator validator = new UrlValidator();
         String url = "http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html";
-        assertTrue("IPv6 address URL should validate: " + url, validator.isValid(url));
+        assertTrue(validator.isValid(url), "IPv6 address URL should validate: " + url);
         url = "http://[::1]:80/index.html";
-        assertTrue("IPv6 address URL should validate: " + url, validator.isValid(url));
+        assertTrue(validator.isValid(url), "IPv6 address URL should validate: " + url);
         url = "http://FEDC:BA98:7654:3210:FEDC:BA98:7654:3210:80/index.html";
-        assertFalse("IPv6 address without [] should not validate: " + url, validator.isValid(url));
+        assertFalse(validator.isValid(url), "IPv6 address without [] should not validate: " + url);
     }
 
     /**

test/unit/org/openstreetmap/josm/data/validation/tests/ConnectivityRelationsTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.validation.tests;
 
-import org.junit.Assert;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -51 +52 @@
         Relation relation = createDefaultTestRelation();
         check.visit(relation);
 
-        Assert.assertEquals(0, check.getErrors().size());
+        assertEquals(0, check.getErrors().size());
 
         relation.remove(CONNECTIVITY);
         check.visit(relation);
-        Assert.assertEquals(1, check.getErrors().size());
+        assertEquals(1, check.getErrors().size());
     }
 
     /**
@@ -67 +68 @@
         check.visit(relation);
         int expectedFailures = 0;
 
-        Assert.assertEquals(expectedFailures, check.getErrors().size());
+        assertEquals(expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "45000:1");
         check.visit(relation);
-        Assert.assertEquals(++expectedFailures, check.getErrors().size());
+        assertEquals(++expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "1:45000");
         check.visit(relation);
-        Assert.assertEquals(++expectedFailures, check.getErrors().size());
+        assertEquals(++expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "1:1,2");
         check.visit(relation);
-        Assert.assertEquals(expectedFailures, check.getErrors().size());
+        assertEquals(expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "1:1,(2)");
         check.visit(relation);
-        Assert.assertEquals(expectedFailures, check.getErrors().size());
+        assertEquals(expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "1:1,(20000)");
         check.visit(relation);
-        Assert.assertEquals(++expectedFailures, check.getErrors().size());
+        assertEquals(++expectedFailures, check.getErrors().size());
     }
 
     /**
@@ -100 +101 @@
         check.visit(relation);
         int expectedFailures = 0;
 
-        Assert.assertEquals(expectedFailures, check.getErrors().size());
+        assertEquals(expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "left_turn");
         check.visit(relation);
-        Assert.assertEquals(++expectedFailures, check.getErrors().size());
+        assertEquals(++expectedFailures, check.getErrors().size());
 
         relation.put(CONNECTIVITY, "1");
         check.visit(relation);
-        Assert.assertEquals(++expectedFailures, check.getErrors().size());
+        assertEquals(++expectedFailures, check.getErrors().size());
     }
 }

test/unit/org/openstreetmap/josm/data/validation/tests/DirectionNodesTest.java

@@ -3 +3 @@
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -27 +28 @@
     @Test
     void testDirectionsNodesTestFile() throws Exception {
         final DirectionNodes test = new DirectionNodes();
-        ValidatorTestUtils.testSampleFile("nodist/data/direction-nodes.osm", ds -> ds.getNodes(), null, test);
+        ValidatorTestUtils.testSampleFile("nodist/data/direction-nodes.osm", DataSet::getNodes, null, test);
     }
 }

test/unit/org/openstreetmap/josm/data/validation/tests/SelfIntersectingWayTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.validation.tests;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.JOSMFixture;
@@ -58 +60 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(1)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(1)));
     }
 
     /**
@@ -81 +83 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(0, test.getErrors().size());
+        assertEquals(0, test.getErrors().size());
     }
 
     /**
@@ -103 +105 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(0, test.getErrors().size());
+        assertEquals(0, test.getErrors().size());
     }
 
     /**
@@ -125 +127 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(0, test.getErrors().size());
+        assertEquals(0, test.getErrors().size());
     }
 
     /**
@@ -148 +150 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
     }
 
     /**
@@ -171 +173 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
     }
 
     /**
@@ -194 +196 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(0)));
     }
 
     /**
@@ -217 +219 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(2)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(2)));
     }
 
     /**
@@ -242 +244 @@
         w.setNodes(wayNodes);
         SelfIntersectingWay test = new SelfIntersectingWay();
         test.visit(w);
-        Assert.assertEquals(1, test.getErrors().size());
-        Assert.assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(3)));
+        assertEquals(1, test.getErrors().size());
+        assertTrue(test.getErrors().iterator().next().getHighlighted().contains(nodes.get(3)));
     }
 
 }

test/unit/org/openstreetmap/josm/data/validation/tests/SharpAnglesTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.validation.tests;
 
-import org.junit.Assert;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.JOSMFixture;
@@ -37 +38 @@
                 new Node(new LatLon(0.1, -0.2)), new Node(new LatLon(-0.1, -0.1)));
         way.addNode(way.firstNode());
         angles.visit(way);
-        Assert.assertEquals(0, angles.getErrors().size());
+        assertEquals(0, angles.getErrors().size());
     }
 
     /**
@@ -51 +52 @@
         way.addNode(way.firstNode());
         angles.setMaxLength(Double.MAX_VALUE);
         angles.visit(way);
-        Assert.assertEquals(1, angles.getErrors().size());
+        assertEquals(1, angles.getErrors().size());
     }
 
     /**
@@ -66 +67 @@
                 new Node(new LatLon(0.005031826787678042, 0.0020116540789620915)));
         angles.setMaxLength(Double.MAX_VALUE);
         angles.visit(way);
-        Assert.assertEquals(2, angles.getErrors().size());
+        assertEquals(2, angles.getErrors().size());
     }
 
     /**
@@ -78 +79 @@
                 new Node(new LatLon(0, 0)), new Node(new LatLon(0.1, 0.1)),
                 new Node(new LatLon(0.2, 0.3)), new Node(new LatLon(0.3, 0.1)));
         angles.visit(way);
-        Assert.assertEquals(0, angles.getErrors().size());
+        assertEquals(0, angles.getErrors().size());
     }
 
     /**
@@ -97 +98 @@
                 new Node(new LatLon(52.8902482, 8.4307568)));
         way.addNode(way.firstNode());
         angles.visit(way);
-        Assert.assertEquals(0, angles.getErrors().size());
+        assertEquals(0, angles.getErrors().size());
     }
 
     /**
@@ -110 +111 @@
                 new Node(new LatLon(0, 0.01)));
         angles.setMaxLength(Double.MAX_VALUE);
         angles.visit(way);
-        Assert.assertEquals(1, angles.getErrors().size());
+        assertEquals(1, angles.getErrors().size());
         angles.getErrors().clear();
 
         way.put("highway", "rest_area");
         angles.visit(way);
-        Assert.assertEquals(0, angles.getErrors().size());
+        assertEquals(0, angles.getErrors().size());
 
         way.put("highway", "residential");
         angles.visit(way);
-        Assert.assertEquals(1, angles.getErrors().size());
+        assertEquals(1, angles.getErrors().size());
         angles.getErrors().clear();
         way.put("area", "yes");
         angles.visit(way);
-        Assert.assertEquals(0, angles.getErrors().size());
+        assertEquals(0, angles.getErrors().size());
         way.put("area", "no");
         angles.visit(way);
-        Assert.assertEquals(1, angles.getErrors().size());
+        assertEquals(1, angles.getErrors().size());
     }
 }

test/unit/org/openstreetmap/josm/data/validation/tests/TagCheckerTest.java

@@ -10 +10 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -265 +265 @@
     }
 
     private static void doTestUnwantedNonprintingControlCharacters(String s) {
-        doTestUnwantedNonprintingControlCharacters(s, Assert::assertTrue, "");
+        doTestUnwantedNonprintingControlCharacters(s, Assertions::assertTrue, "");
     }
 
     /**
@@ -275 +275 @@
     @Test
     void testContainsRemoveUnwantedNonprintingControlCharacters() {
         // Check empty string is handled
-        doTestUnwantedNonprintingControlCharacters("", Assert::assertFalse, "");
+        doTestUnwantedNonprintingControlCharacters("", Assertions::assertFalse, "");
         // Check 65 ASCII control characters are removed, except new lines
         for (char c = 0x0; c < 0x20; c++) {
             if (c != '\r' && c != '\n') {
                 doTestUnwantedNonprintingControlCharacters(Character.toString(c));
             } else {
-                doTestUnwantedNonprintingControlCharacters(Character.toString(c), Assert::assertFalse, Character.toString(c));
+                doTestUnwantedNonprintingControlCharacters(Character.toString(c), Assertions::assertFalse, Character.toString(c));
             }
         }
         doTestUnwantedNonprintingControlCharacters(Character.toString((char) 0x7F));
@@ -297 +297 @@
             final String s = Character.toString(c);
             doTestUnwantedNonprintingControlCharacters(s);
             doTestUnwantedNonprintingControlCharacters(s + s);
-            doTestUnwantedNonprintingControlCharacters(s + 'a' + s, Assert::assertTrue, "a");
+            doTestUnwantedNonprintingControlCharacters(s + 'a' + s, Assertions::assertTrue, "a");
             final String ok = 'a' + s + 'b';
-            doTestUnwantedNonprintingControlCharacters(ok, Assert::assertFalse, ok);
-            doTestUnwantedNonprintingControlCharacters(s + ok, Assert::assertTrue, ok);
-            doTestUnwantedNonprintingControlCharacters(ok + s, Assert::assertTrue, ok);
-            doTestUnwantedNonprintingControlCharacters(s + ok + s, Assert::assertTrue, ok);
+            doTestUnwantedNonprintingControlCharacters(ok, Assertions::assertFalse, ok);
+            doTestUnwantedNonprintingControlCharacters(s + ok, Assertions::assertTrue, ok);
+            doTestUnwantedNonprintingControlCharacters(ok + s, Assertions::assertTrue, ok);
+            doTestUnwantedNonprintingControlCharacters(s + ok + s, Assertions::assertTrue, ok);
         }
     }
 

test/unit/org/openstreetmap/josm/data/validation/tests/TurnRestrictionTestTest.java

@@ -3 +3 @@
 
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -29 +30 @@
     @Test
     void testTurnrestrictionFile() throws Exception {
         ValidatorTestUtils.testSampleFile("nodist/data/restriction.osm",
-                ds -> ds.getRelations(),
+                DataSet::getRelations,
                 name -> name.startsWith("E"), TURNRESTRICTION_TEST, RELATION_TEST);
     }
 }

test/unit/org/openstreetmap/josm/gui/datatransfer/data/PrimitiveTagTransferDataTest.java

@@ -3 +3 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 import java.util.Map;
 
+import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.NodeData;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
@@ -17 +19 @@
 import org.openstreetmap.josm.data.osm.WayData;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 
-import org.junit.jupiter.api.Test;
-
 /**
  * Test {@link PrimitiveTagTransferData}
  * @author Michael Zangl
@@ -108 +108 @@
         Map<OsmPrimitiveType, Integer> stats = data.getStatistics();
         assertEquals(2, (int) stats.get(OsmPrimitiveType.NODE));
         assertEquals(1, (int) stats.get(OsmPrimitiveType.WAY));
-        assertEquals(null, stats.get(OsmPrimitiveType.RELATION));
+        assertNull(stats.get(OsmPrimitiveType.RELATION));
     }
 }

test/unit/org/openstreetmap/josm/gui/datatransfer/ClipboardUtilsTest.java

@@ -83 +83 @@
         assertEquals("xxx\nx", ClipboardUtils.getClipboardStringContent());
 
         ClipboardUtils.copy(new SupportNothingTransferable());
-        assertEquals(null, ClipboardUtils.getClipboardStringContent());
+        assertNull(ClipboardUtils.getClipboardStringContent());
     }
 
     /**

test/unit/org/openstreetmap/josm/gui/dialogs/layer/DuplicateActionTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui.dialogs.layer;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
@@ -36 +36 @@
                 new DuplicateAction(layer, null).actionPerformed(null);
                 editLayer = MainApplication.getLayerManager().getEditLayer();
                 assertNotNull(editLayer);
-                assertFalse(layer.equals(editLayer));
+                assertNotEquals(layer, editLayer);
                 assertEquals(layer.data.getNodes().size(), editLayer.data.getNodes().size());
                 assertEquals(layer.data.getWays().size(), editLayer.data.getWays().size());
                 assertEquals(layer.data.getRelations().size(), editLayer.data.getRelations().size());

test/unit/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationSorterTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.dialogs.relation.sort;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -67 +69 @@
         String[] actual = getNames(sorter.sortMembers(getRelation("generic").getMembers()));
         final String[] expected = {"t1w4", "t1w3", "t1w2", "t1w1", "t1w7", "t1w6", "t1w5", "t1n1", "t1n2"};
         // expect nodes to be sorted correctly
-        Assert.assertEquals(expected[7], actual[7]);
-        Assert.assertEquals(expected[8], actual[8]);
+        assertEquals(expected[7], actual[7]);
+        assertEquals(expected[8], actual[8]);
     }
 
     @Test
     void testAssociatedStreet() {
         String[] actual = getNames(sorter.sortMembers(getRelation("associatedStreet").getMembers()));
-        Assert.assertArrayEquals(new String[] {"t2w1", "t2w2", "t2n1", "t2n2", "t2n3", "t2n4"}, actual);
+        assertArrayEquals(new String[] {"t2w1", "t2w2", "t2n1", "t2n2", "t2n3", "t2n4"}, actual);
     }
 
     @Test
     void testStreet() {
         String[] actual = getNames(sorter.sortMembers(getRelation("street").getMembers()));
-        Assert.assertArrayEquals(new String[]{"t2w1", "t2w2", "t2n1", "t2n2", "t2n3", "t2n4", "playground", "tree"}, actual);
+        assertArrayEquals(new String[]{"t2w1", "t2w2", "t2n1", "t2n2", "t2n3", "t2n4", "playground", "tree"}, actual);
     }
 
     // The following cluster of tests does the same, but with various
@@ -93 +95 @@
         Relation relation = getRelation("three-loops-ends-loop");
         // Check the first way before sorting, otherwise the sorter
         // might pick a different loop starting point than expected below
-        Assert.assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
 
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w1", "t5w2a", "t5w3a", "t5w4a", "t5w2b", "t5w3b", "t5w4b",
             "t5w5", "t5w6a", "t5w7a", "t5w8a", "t5w6b", "t5w7b", "t5w8b",
             "t5w9a", "t5w10a", "t5w11a", "t5w9b", "t5w10b", "t5w11b",
@@ -109 +111 @@
         Relation relation = getRelation("three-loops-ends-way");
         // Check the first way before sorting, otherwise the sorter
         // might sort in reverse compared to what is expected below
-        Assert.assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
 
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w1", "t5w2a", "t5w3a", "t5w4a", "t5w2b", "t5w3b", "t5w4b",
             "t5w5", "t5w6a", "t5w7a", "t5w8a", "t5w6b", "t5w7b", "t5w8b",
             "t5w9a", "t5w10a", "t5w11a", "t5w9b", "t5w10b", "t5w11b",
@@ -124 +126 @@
     void testThreeLoopsEndsNode() {
         Relation relation = getRelation("three-loops-ends-node");
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w4a", "t5w3a", "t5w2a", "t5w2b", "t5w3b", "t5w4b",
             "t5w5", "t5w6a", "t5w7a", "t5w8a", "t5w6b", "t5w7b", "t5w8b",
             "t5w9a", "t5w10a", "t5w11a", "t5w11b", "t5w10b", "t5w9b",
@@ -135 +137 @@
     void testOneLoopEndsSplit() {
         Relation relation = getRelation("one-loop-ends-split");
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w3a", "t5w4a", "t5w3b", "t5w4b",
             "t5w5", "t5w6a", "t5w7a", "t5w8a", "t5w6b", "t5w7b", "t5w8b",
             "t5w9a", "t5w10a", "t5w9b", "t5w10b",
@@ -149 +151 @@
         // presorted in the data file, making this a bit of a dummy test
         // for now.
         String[] actual = getNames(relation.getMembers());
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w7a", "t5w8a", "t5w7b", "t5w8b",
             "t5w9a", "t5w10a", "t5w9b", "t5w10b",
         }, actual);
@@ -160 +162 @@
         Relation relation = getRelation("incomplete-loops");
         // TODO: This is not yet sorted perfectly (might not be possible)
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t5w1", "t5w2a", "t5w3a", "t5w4a", "t5w2b", "t5w3b",
             "t5w5", "t5w6a", "t5w7a", "t5w8a", "t5w9a", "t5w10a", "t5w11a", "t5w6b", "t5w7b",
             "t5w12", "t5w11b", "t5w10b", "t5w9b",
@@ -172 +174 @@
         Relation relation = getRelation("parallel-oneway");
         // TODO: This is not always sorted properly, only when the right
         // way is already at the top, so check that
-        Assert.assertEquals("t6w1a", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t6w1a", relation.getMembers().get(0).getMember().get("name"));
 
         String[] actual = getNames(sorter.sortMembers(relation.getMembers()));
-        Assert.assertArrayEquals(new String[]{
+        assertArrayEquals(new String[]{
             "t6w1a", "t6w2a", "t6w3a",
             "t6w1b", "t6w2b", "t6w3b",
         }, actual);

test/unit/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculatorTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.dialogs.relation.sort;
 
+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 java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
@@ -11 +15 @@
 import java.util.HashSet;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -101 +104 @@
     @Test
     void testEmpty() {
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(new ArrayList<>()));
-        Assert.assertEquals("[]", actual);
+        assertEquals("[]", actual);
     }
 
     // This cluster of tests checks the rendering before and after
@@ -112 +115 @@
     void testGeneric() {
         Relation relation = getRelation("generic");
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(relation.getMembers()));
-        Assert.assertEquals("[NONE, NONE, FORWARD, FORWARD, NONE, NONE, NONE, I, I]", actual);
+        assertEquals("[NONE, NONE, FORWARD, FORWARD, NONE, NONE, NONE, I, I]", actual);
         actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
-        Assert.assertEquals("[FORWARD, FORWARD, FORWARD, FORWARD, BACKWARD, BACKWARD, NONE, I, I]", actual);
+        assertEquals("[FORWARD, FORWARD, FORWARD, FORWARD, BACKWARD, BACKWARD, NONE, I, I]", actual);
     }
 
     @Test
     void testAssociatedStreet() {
         Relation relation = getRelation("associatedStreet");
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(relation.getMembers()));
-        Assert.assertEquals("[NONE, I, I, I, NONE, I]", actual);
+        assertEquals("[NONE, I, I, I, NONE, I]", actual);
         actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
-        Assert.assertEquals("[FORWARD, FORWARD, I, I, I, I]", actual);
+        assertEquals("[FORWARD, FORWARD, I, I, I, I]", actual);
     }
 
     @Test
     void testLoop() {
         Relation relation = getRelation("loop");
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(relation.getMembers()));
-        Assert.assertEquals("[FPH FORWARD, FP FORWARD, NONE, FPH FORWARD, NONE, FPH FORWARD, NONE]", actual);
+        assertEquals("[FPH FORWARD, FP FORWARD, NONE, FPH FORWARD, NONE, FPH FORWARD, NONE]", actual);
         //TODO Sorting doesn't work well in this case
         actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
-        Assert.assertEquals("[BACKWARD, BACKWARD, BACKWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD]", actual);
+        assertEquals("[BACKWARD, BACKWARD, BACKWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD]", actual);
     }
 
     // The following cluster of tests checks various configurations
@@ -146 +149 @@
         Relation relation = getRelation("three-loops-ends-loop");
         // Check the first way before sorting, otherwise the sorter
         // might pick a different loop starting point than expected below
-        Assert.assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
         String expected = "[" +
             "L FORWARD, LFPH FORWARD, LFP FORWARD, LFP FORWARD, LBP BACKWARD, LBP BACKWARD, LBPT BACKWARD, " +
@@ -154 +157 @@
             "LFPH FORWARD, LFP FORWARD, LFP FORWARD, LBP BACKWARD, LBP BACKWARD, LBPT BACKWARD, " +
             "L FORWARD, L FORWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -162 +165 @@
         Relation relation = getRelation("three-loops-ends-way");
         // Check the first way before sorting, otherwise the sorter
         // might sort in reverse compared to what is expected below
-        Assert.assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t5w1", relation.getMembers().get(0).getMember().get("name"));
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
         String expected = "[" +
             "FORWARD, FPH FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD, " +
@@ -170 +173 @@
             "FPH FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD, " +
             "FORWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -182 +185 @@
             "FORWARD, FPH FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD, " +
             "FPH FORWARD, FP FORWARD, FP FORWARD, FP FORWARD, FP FORWARD, BPT BACKWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -194 +197 @@
             "FORWARD, FPH FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BPT BACKWARD, " +
             "FPH FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -207 +210 @@
             "FP FORWARD, FP FORWARD, BP BACKWARD, BPT BACKWARD, " +
             "FPH FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -220 +223 @@
             "FORWARD, FPH FORWARD, FP FORWARD, FP FORWARD, FP FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, " +
             "BACKWARD, FPH FORWARD, FP FORWARD, FP FORWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -228 +231 @@
         Relation relation = getRelation("parallel-oneway");
         // TODO: This is not always sorted properly, only when the right
         // way is already at the top, so check that
-        Assert.assertEquals("t6w1a", relation.getMembers().get(0).getMember().get("name"));
+        assertEquals("t6w1a", relation.getMembers().get(0).getMember().get("name"));
         String actual = getConnections(wayConnectionTypeCalculator.updateLinks(sorter.sortMembers(relation.getMembers())));
         String expected = "[" +
             "FP FORWARD, FP FORWARD, FP FORWARD, BP BACKWARD, BP BACKWARD, BP BACKWARD" +
         "]";
-        Assert.assertEquals(expected, actual);
+        assertEquals(expected, actual);
     }
 
     private void reverseWay(Way way) {
@@ -255 +258 @@
         // Check with only one wrong oneway
         List<WayConnectionType> returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
         for (int i = 0; i < 4; i++) {
-            Assert.assertTrue(returned.get(i).onewayFollowsPrevious);
-            Assert.assertTrue(returned.get(i).onewayFollowsNext);
+            assertTrue(returned.get(i).onewayFollowsPrevious);
+            assertTrue(returned.get(i).onewayFollowsNext);
         }
 
-        Assert.assertTrue(returned.get(4).onewayFollowsPrevious);
-        Assert.assertFalse(returned.get(4).onewayFollowsNext);
+        assertTrue(returned.get(4).onewayFollowsPrevious);
+        assertFalse(returned.get(4).onewayFollowsNext);
 
-        Assert.assertFalse(returned.get(5).onewayFollowsPrevious);
-        Assert.assertFalse(returned.get(5).onewayFollowsNext);
+        assertFalse(returned.get(5).onewayFollowsPrevious);
+        assertFalse(returned.get(5).onewayFollowsNext);
 
-        Assert.assertFalse(returned.get(6).onewayFollowsPrevious);
-        Assert.assertTrue(returned.get(6).onewayFollowsNext);
+        assertFalse(returned.get(6).onewayFollowsPrevious);
+        assertTrue(returned.get(6).onewayFollowsNext);
 
         // Reverse the last oneway
         OsmPrimitive way7 = relation.getMemberPrimitivesList().get(6);
@@ -275 +278 @@
             reverseWay(way);
             returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
             for (int i = 0; i < 4; i++) {
-                Assert.assertTrue(returned.get(i).onewayFollowsPrevious);
-                Assert.assertTrue(returned.get(i).onewayFollowsNext);
+                assertTrue(returned.get(i).onewayFollowsPrevious);
+                assertTrue(returned.get(i).onewayFollowsNext);
             }
 
-            Assert.assertTrue(returned.get(4).onewayFollowsPrevious);
-            Assert.assertFalse(returned.get(4).onewayFollowsNext);
+            assertTrue(returned.get(4).onewayFollowsPrevious);
+            assertFalse(returned.get(4).onewayFollowsNext);
 
-            Assert.assertFalse(returned.get(5).onewayFollowsPrevious);
-            Assert.assertTrue(returned.get(5).onewayFollowsNext);
+            assertFalse(returned.get(5).onewayFollowsPrevious);
+            assertTrue(returned.get(5).onewayFollowsNext);
 
-            Assert.assertTrue(returned.get(6).onewayFollowsPrevious);
-            Assert.assertTrue(returned.get(6).onewayFollowsNext);
+            assertTrue(returned.get(6).onewayFollowsPrevious);
+            assertTrue(returned.get(6).onewayFollowsNext);
             reverseWay(way);
         }
 
@@ -297 +300 @@
             reverseWay(way);
             returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
             for (int i = 0; i < 7; i++) {
-                Assert.assertTrue(returned.get(i).onewayFollowsPrevious);
-                Assert.assertTrue(returned.get(i).onewayFollowsNext);
+                assertTrue(returned.get(i).onewayFollowsPrevious);
+                assertTrue(returned.get(i).onewayFollowsNext);
             }
         }
 
@@ -308 +311 @@
         }
         returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
         for (int i = 0; i < 7; i++) {
-            Assert.assertTrue(returned.get(i).onewayFollowsPrevious);
-            Assert.assertTrue(returned.get(i).onewayFollowsNext);
+            assertTrue(returned.get(i).onewayFollowsPrevious);
+            assertTrue(returned.get(i).onewayFollowsNext);
         }
     }
 
@@ -325 +328 @@
         osm.remove("oneway");
         List<WayConnectionType> returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
         for (WayConnectionType type : returned) {
-            Assert.assertTrue(type.onewayFollowsNext);
-            Assert.assertTrue(type.onewayFollowsPrevious);
+            assertTrue(type.onewayFollowsNext);
+            assertTrue(type.onewayFollowsPrevious);
         }
 
         // Check with a oneway=-1 tag without reversing the way
         osm.put("oneway", "-1");
         returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
         for (WayConnectionType type : returned) {
-            Assert.assertTrue(type.onewayFollowsNext);
-            Assert.assertTrue(type.onewayFollowsPrevious);
+            assertTrue(type.onewayFollowsNext);
+            assertTrue(type.onewayFollowsPrevious);
         }
 
         // Check with oneways that converge onto a two-way
@@ -345 +348 @@
         returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
         for (int i = 0; i < returned.size() - 1; i++) {
             WayConnectionType type = returned.get(i);
-            Assert.assertTrue(type.onewayFollowsNext);
-            Assert.assertTrue(type.onewayFollowsPrevious);
+            assertTrue(type.onewayFollowsNext);
+            assertTrue(type.onewayFollowsPrevious);
         }
-        Assert.assertTrue(returned.get(6).onewayFollowsNext);
-        Assert.assertFalse(returned.get(6).onewayFollowsPrevious);
+        assertTrue(returned.get(6).onewayFollowsNext);
+        assertFalse(returned.get(6).onewayFollowsPrevious);
     }
 }

test/unit/org/openstreetmap/josm/gui/dialogs/validator/ValidatorTreePanelTest.java

@@ -70 +70 @@
         Set<? extends OsmPrimitive> filter = new HashSet<>(Arrays.asList(n));
         vtp.setFilter(filter);
         assertEquals(filter, vtp.getFilter());
-        vtp.setFilter(new HashSet<OsmPrimitive>());
+        vtp.setFilter(new HashSet<>());
         assertNull(vtp.getFilter());
         vtp.setFilter(null);
         assertNull(vtp.getFilter());

test/unit/org/openstreetmap/josm/gui/history/HistoryLoadTaskTest.java

@@ -52 +52 @@
     }
 
     /**
-     * Unit test of {@link HistoryLoadTask#loadHistory}
+     * Unit test of {@link HistoryLoadTask#loadHistory(OsmServerHistoryReader, ProgressMonitor)}
      * @throws OsmTransferException if an error occurs
      */
     @Test

test/unit/org/openstreetmap/josm/gui/io/AsynchronousUploadPrimitivesTaskTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.io;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 import java.util.Collections;
 import java.util.Optional;
 
 import javax.swing.JOptionPane;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -93 +95 @@
             ));
         Optional<AsynchronousUploadPrimitivesTask> task = AsynchronousUploadPrimitivesTask.
                 createAsynchronousUploadTask(strategy, layer, toUpload, changeset);
-        Assert.assertNotNull(uploadPrimitivesTask);
-        Assert.assertFalse(task.isPresent());
+        assertNotNull(uploadPrimitivesTask);
+        assertFalse(task.isPresent());
     }
 }

test/unit/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerActionTest.java

@@ -140 +140 @@
         assertEquals(nodesExpected, nodes, "Conversion " + originalGpx + " -> " + expectedOsm + " didn't match!");
 
         List<String> ways = osm.getWays().stream()
-                .map(w -> Integer.toString(w.getNodes().size()) + ":" + w.getKeys().entrySet().stream()
-                        .sorted(Comparator.comparing(Map.Entry::getKey)).collect(Collectors.toList()).toString())
+                .map(w -> w.getNodes().size() + ":" + w.getKeys().entrySet().stream()
+                        .sorted(Map.Entry.comparingByKey()).collect(Collectors.toList()))
                 .sorted()
                 .collect(Collectors.toList());
 
         List<String> waysExpected = osmExpected.getWays().stream()
-                .map(w -> Integer.toString(w.getNodes().size()) + ":" + w.getKeys().entrySet().stream()
-                        .sorted(Comparator.comparing(Map.Entry::getKey)).collect(Collectors.toList()).toString())
+                .map(w -> w.getNodes().size() + ":" + w.getKeys().entrySet().stream()
+                        .sorted(Map.Entry.comparingByKey()).collect(Collectors.toList()))
                 .sorted()
                 .collect(Collectors.toList());
 

test/unit/org/openstreetmap/josm/gui/layer/GpxLayerTest.java

@@ -210 +210 @@
     @Test
     void testGetTimespanForTrack() throws Exception {
         assertEquals("", GpxLayer.getTimespanForTrack(
-                new GpxTrack(new ArrayList<Collection<WayPoint>>(), new HashMap<String, Object>())));
+                new GpxTrack(new ArrayList<Collection<WayPoint>>(), new HashMap<>())));
 
         assertEquals("2016-01-03 11:59:58 \u2013 12:00:00 (2.0 s)", GpxLayer.getTimespanForTrack(getMinimalGpxData().tracks.iterator().next()));
 
@@ -303 +303 @@
         assertTrue(text.startsWith("<html>"), text);
         assertTrue(text.endsWith("</html>"), text);
         assertEquals("<html><br></html>", layer.getToolTipText());
-        assertDoesNotThrow(() -> layer.jumpToNextMarker());
-        assertDoesNotThrow(() -> layer.jumpToPreviousMarker());
+        assertDoesNotThrow(layer::jumpToNextMarker);
+        assertDoesNotThrow(layer::jumpToPreviousMarker);
         assertDoesNotThrow(() -> layer.visitBoundingBox(new BoundingXYVisitor()));
         assertDoesNotThrow(() -> layer.filterTracksByDate(null, null, false));
         assertDoesNotThrow(() -> layer.projectionChanged(new CustomProjection(), new CustomProjection()));

test/unit/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSParserTest.java

@@ -15 +15 @@
 import java.util.List;
 import java.util.regex.Pattern;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -314 +313 @@
 
     private void tagRegex(Way way, String parserString, Boolean[] expected) throws Exception {
         Selector selector = getParser(parserString).selector();
-        Assert.assertEquals(expected[0], selector.matches(new Environment(way)));
+        assertEquals(expected[0], selector.matches(new Environment(way)));
         way.put("old_ref", null);
-        Assert.assertEquals(expected[1], selector.matches(new Environment(way)));
+        assertEquals(expected[1], selector.matches(new Environment(way)));
         way.put("no_match_tag", "false");
-        Assert.assertEquals(expected[2], selector.matches(new Environment(way)));
+        assertEquals(expected[2], selector.matches(new Environment(way)));
         way.put("old_ref", "A22");
-        Assert.assertEquals(expected[3], selector.matches(new Environment(way)));
+        assertEquals(expected[3], selector.matches(new Environment(way)));
         way.put("old_ref", null);
         way.put("OLD_REF", "A23");
-        Assert.assertEquals(expected[4], selector.matches(new Environment(way)));
+        assertEquals(expected[4], selector.matches(new Environment(way)));
     }
 
     @Test

test/unit/org/openstreetmap/josm/gui/preferences/imagery/ImageryPreferenceTestIT.java

@@ -145 +145 @@
     }
 
     private static boolean isIgnoredSubstring(String substring) {
-        return errorsToIgnore.parallelStream().anyMatch(x -> substring.contains(x));
+        return errorsToIgnore.parallelStream().anyMatch(substring::contains);
     }
 
     private static boolean addError(Map<String, Map<ImageryInfo, List<String>>> map, ImageryInfo info, String errorMsg) {
@@ -341 +341 @@
                 checkTileUrls(info, tileSources, center, Utils.clamp(DEFAULT_ZOOM, info.getMinZoom() + 1, info.getMaxZoom()));
             }
         } catch (IOException | RuntimeException | WMSGetCapabilitiesException e) {
-            addError(info, info.getUrl() + ERROR_SEP + e.toString());
+            addError(info, info.getUrl() + ERROR_SEP + e);
         }
 
         for (ImageryInfo mirror : info.getMirrors()) {
@@ -393 +393 @@
             try {
                 return new WMTSTileSource(info, proj);
             } catch (IOException | WMTSGetCapabilitiesException e) {
-                addError(info, info.getUrl() + ERROR_SEP + e.toString());
+                addError(info, info.getUrl() + ERROR_SEP + e);
                 return null;
             }
         }).filter(Objects::nonNull).collect(toList());

test/unit/org/openstreetmap/josm/gui/preferences/AbstractExtendedSourceEntryTestCase.java

@@ -44 +44 @@
 
     protected final void handleException(ExtendedSourceEntry source, Throwable e, Set<String> errors, List<String> ignoredErrors) {
         e.printStackTrace();
-        String s = source.url + " => " + e.toString();
+        String s = source.url + " => " + e;
         if (isIgnoredSubstring(source, s)) {
             ignoredErrors.add(s);
         } else {

test/unit/org/openstreetmap/josm/gui/preferences/ToolbarPreferencesTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.preferences;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.awt.event.ActionEvent;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -10 +12 @@
 import javax.swing.AbstractAction;
 import javax.swing.Action;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.actions.ActionParameter;
 import org.openstreetmap.josm.actions.ActionParameter.StringActionParameter;
@@ -53 +54 @@
         for (int i = 0; i < params.length; i += 2) {
             expected.put((String) params[i], params[i+1]);
         }
-        Assert.assertEquals(expected, a.getParameters());
+        assertEquals(expected, a.getParameters());
     }
 
     @Test
@@ -72 +73 @@
         checkAction(parser.loadAction("action"));
         checkAction(parser.loadAction("action(uknownParam=aa)"));
 
-        Assert.assertEquals("action(param1=value1,param2=value2)",
-                parser.saveAction(parser.loadAction("action(param1=value1,param2=value2)")));
-        Assert.assertEquals("action(param1=value1,param2=)",
-                parser.saveAction(parser.loadAction("action(param1=value1)")));
-        Assert.assertEquals("action(param1=value1,param2=2\\(\\=\\,\\\\)",
-                parser.saveAction(parser.loadAction("action(param1=value1,param2=2\\(\\=\\,\\\\)")));
+        assertEquals("action(param1=value1,param2=value2)", parser.saveAction(parser.loadAction("action(param1=value1,param2=value2)")));
+        assertEquals("action(param1=value1,param2=)", parser.saveAction(parser.loadAction("action(param1=value1)")));
+        assertEquals(
+                "action(param1=value1,param2=2\\(\\=\\,\\\\)",
+                parser.saveAction(parser.loadAction("action(param1=value1,param2=2\\(\\=\\,\\\\)"))
+        );
     }
 }

test/unit/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetReaderTest.java

@@ -12 +12 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.openstreetmap.josm.TestUtils;
@@ -44 +43 @@
     void testTicket8954() throws SAXException, IOException {
         String presetfile = TestUtils.getRegressionDataFile(8954, "preset.xml");
         final Collection<TaggingPreset> presets = TaggingPresetReader.readAll(presetfile, false);
-        Assert.assertEquals("Number of preset items", 1, presets.size());
+        assertEquals(1, presets.size(), "Number of preset items");
         final TaggingPreset preset = presets.iterator().next();
-        Assert.assertEquals("Number of entries", 1, preset.data.size());
+        assertEquals(1, preset.data.size(), "Number of entries");
         final TaggingPresetItem item = preset.data.get(0);
-        Assert.assertTrue("Entry is not checkbox", item instanceof Check);
+        assertTrue(item instanceof Check, "Entry is not checkbox");
     }
 
     /**
@@ -92 +91 @@
     void testReadDefaulPresets() throws SAXException, IOException {
         String presetfile = "resource://data/defaultpresets.xml";
         final Collection<TaggingPreset> presets = TaggingPresetReader.readAll(presetfile, true);
-        Assert.assertTrue("Default presets are empty", presets.size() > 0);
+        assertTrue(presets.size() > 0, "Default presets are empty");
     }
 }

test/unit/org/openstreetmap/josm/gui/widgets/HistoryComboBoxTest.java

@@ -20 +20 @@
 @FullPreferences
 class HistoryComboBoxTest {
     static Stream<Arguments> testNonRegression21203() {
-        return Stream.of(Arguments.of("Hello world"), Arguments.of(new AutoCompletionItem("Hello world2")), Arguments.of(new Double(42)));
+        return Stream.of(Arguments.of("Hello world"), Arguments.of(new AutoCompletionItem("Hello world2")), Arguments.of(42.0));
     }
 
     /**
@@ -58 +58 @@
         historyComboBox.getEditor().setItem(testItem);
         historyComboBox.addCurrentItemToHistory();
 
-        // add a new item
+        // Add a new item
         historyComboBox.getEditor().setItem(new AutoCompletionItem("testNonRegression21215_2"));
         historyComboBox.addCurrentItemToHistory();
 

test/unit/org/openstreetmap/josm/gui/MapViewStateTest.java

@@ -64 +64 @@
      */
     @Test
     void testGetCenter() {
-        doTestGetCenter(s -> s.getCenter(), t -> t / 2d);
+        doTestGetCenter(MapViewState::getCenter, t -> t / 2d);
     }
 
     private static void assertHasViewCoords(double x, double y, MapViewPoint center) {

test/unit/org/openstreetmap/josm/gui/NavigatableComponentTest.java

@@ -91 +91 @@
     void testPoint2DEastNorth() {
         assertThat(component.getPoint2D((EastNorth) null), CustomMatchers.is(new Point2D.Double()));
         Point2D shouldBeCenter = component.getPoint2D(component.getCenter());
-        assertThat(shouldBeCenter, CustomMatchers.is(new Point2D.Double(WIDTH / 2, HEIGHT / 2)));
+        assertThat(shouldBeCenter, CustomMatchers.is(new Point2D.Double(WIDTH / 2.0, HEIGHT / 2.0)));
 
         EastNorth testPoint = component.getCenter().add(300 * component.getScale(), 200 * component.getScale());
         Point2D testPointConverted = component.getPoint2D(testPoint);
-        assertThat(testPointConverted, CustomMatchers.is(new Point2D.Double(WIDTH / 2 + 300, HEIGHT / 2 - 200)));
+        assertThat(testPointConverted, CustomMatchers.is(new Point2D.Double(WIDTH / 2.0 + 300, HEIGHT / 2.0 - 200)));
     }
 
     /**

test/unit/org/openstreetmap/josm/gui/TableCellRendererTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
@@ -13 +14 @@
 import javax.swing.JTable;
 import javax.swing.table.TableCellRenderer;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
@@ -63 +63 @@
     @Test
     void testTableCellRenderer() throws ReflectiveOperationException {
         Set<Class<? extends TableCellRenderer>> renderers = TestUtils.getJosmSubtypes(TableCellRenderer.class);
-        Assert.assertTrue(renderers.size() >= 10); // if it finds less than 10 classes, something is broken
+        assertTrue(renderers.size() >= 10); // if it finds less than 10 classes, something is broken
         JTable tbl = new JTable(2, 2);
         for (Class<? extends TableCellRenderer> klass : renderers) {
             if (Modifier.isAbstract(klass.getModifiers()) || SKIP_TEST.contains(klass.getName())) {

test/unit/org/openstreetmap/josm/io/nmea/NmeaReaderTest.java

@@ -3 +3 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.ByteArrayInputStream;
@@ -69 +70 @@
         assertEquals("16", wayPoints.get(0).get(GpxConstants.PT_SAT));
         assertEquals("3d", wayPoints.get(0).get(GpxConstants.PT_FIX));
         assertEquals("0.7", wayPoints.get(0).get(GpxConstants.PT_HDOP).toString().trim());
-        assertEquals(null, wayPoints.get(0).get(GpxConstants.PT_VDOP));
-        assertEquals(null, wayPoints.get(0).get(GpxConstants.PT_PDOP));
+        assertNull(wayPoints.get(0).get(GpxConstants.PT_VDOP));
+        assertNull(wayPoints.get(0).get(GpxConstants.PT_PDOP));
     }
 
     private static void compareWithReference(int ticket, String filename, int numCoor) throws IOException, SAXException {

test/unit/org/openstreetmap/josm/io/session/SessionWriterTest.java

@@ -129 +129 @@
                 ((MarkerSessionExporter) s).setMetaTime(Instant.parse("2021-10-16T18:27:12.351Z"));
             }
         }
-        SessionWriter sw = new SessionWriter(layers, -1, exporters, new MultiMap<Layer, Layer>(), zip);
+        SessionWriter sw = new SessionWriter(layers, -1, exporters, new MultiMap<>(), zip);
         File file = new File(System.getProperty("java.io.tmpdir"), getClass().getName()+(zip ? ".joz" : ".jos"));
         try {
             sw.write(file);

test/unit/org/openstreetmap/josm/io/CertificateAmendmentTestIT.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.io;
 
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.junit.jupiter.api.Assumptions.assumeFalse;
 
 import java.io.IOException;
@@ -11 +12 @@
 
 import javax.net.ssl.SSLHandshakeException;
 
-import org.junit.Assert;
 import org.junit.ClassRule;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -110 +110 @@
         String error = "Expected error: " + url;
         assumeFalse(errorsToIgnore.contains(error));
         if (!shouldWork) {
-            Assert.fail(error);
+            fail(error);
         }
     }
 }

test/unit/org/openstreetmap/josm/io/OsmChangesetContentParserTest.java

@@ -50 +50 @@
         // should be OK
         new OsmChangesetContentParser(new ByteArrayInputStream("".getBytes(StandardCharsets.UTF_8)));
 
-        shouldFail(() -> {
-            new OsmChangesetContentParser((String) null);
-        });
+        shouldFail(() -> new OsmChangesetContentParser((String) null));
 
-        shouldFail(() -> {
-            new OsmChangesetContentParser((InputStream) null);
-        });
+        shouldFail(() -> new OsmChangesetContentParser((InputStream) null));
     }
 
     /**

test/unit/org/openstreetmap/josm/io/OsmWriterTest.java

@@ -13 +13 @@
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -47 +46 @@
             ids.add(n);
         }
 
-        Collections.sort(ids, OsmWriter.byIdComparator);
+        ids.sort(OsmWriter.byIdComparator);
 
         final long[] longIds = ids.stream().mapToLong(NodeData::getUniqueId).toArray();
         assertArrayEquals(new long[] {

test/unit/org/openstreetmap/josm/io/UrlPatternsTest.java

@@ -36 +36 @@
     @Test
     void testUrlPatterns() {
         assertTrue(patterns.stream().flatMap(c -> Arrays.stream(c.getEnumConstants())).map(t -> ((UrlPattern) t).pattern())
-                .map(Pattern::compile).count() > 0);
+                .map(Pattern::compile).findAny().isPresent());
     }
 }

test/unit/org/openstreetmap/josm/plugins/PluginHandlerTestIT.java

@@ -73 +73 @@
 
         Map<String, Throwable> loadingExceptions = PluginHandler.pluginLoadingExceptions.entrySet().stream()
                 .filter(e -> !(Utils.getRootCause(e.getValue()) instanceof HeadlessException))
-                .collect(Collectors.toMap(e -> e.getKey(), e -> Utils.getRootCause(e.getValue())));
+                .collect(Collectors.toMap(Entry::getKey, e -> Utils.getRootCause(e.getValue())));
 
         List<PluginInformation> loadedPlugins = PluginHandler.getPlugins();
         Map<String, List<String>> invalidManifestEntries = loadedPlugins.stream().filter(pi -> !pi.invalidManifestEntries.isEmpty())
@@ -153 +153 @@
     private static void debugPrint(Map<String, ?> invalidManifestEntries) {
         System.out.println(invalidManifestEntries.entrySet()
                 .stream()
-                .map(e -> convertEntryToString(e))
+                .map(PluginHandlerTestIT::convertEntryToString)
                 .collect(Collectors.joining(", ")));
     }
 

test/unit/org/openstreetmap/josm/testutils/mockers/ExtendedDialogMocker.java

@@ -87 +87 @@
     }
 
     protected String getString(final ExtendedDialog instance) {
-        return Optional.ofNullable(this.simpleStringContentMemo.get(instance))
-            .orElseGet(() -> instance.toString());
+        return Optional.ofNullable(this.simpleStringContentMemo.get(instance)).orElseGet(instance::toString);
     }
 
     protected int getMockResult(final ExtendedDialog instance) {
@@ -153 +152 @@
 
     @Mock
     private void setVisible(final Invocation invocation, final boolean value) throws Throwable {
-        if (value == true) {
+        if (value) {
             try {
                 final ExtendedDialog instance = invocation.getInvokedInstance();
                 this.act(instance);

test/unit/org/openstreetmap/josm/testutils/ImagePatternMatching.java

@@ -37 +37 @@
             // using "#" as the default "unmapped" character as it can be used in regexes without escaping
             .orElse(i -> paletteMap.getOrDefault(i, "#"));
         pattern = Optional.ofNullable(pattern)
-            .orElseGet(() -> patternCache.computeIfAbsent(patternString, k -> Pattern.compile(k)));
+            .orElseGet(() -> patternCache.computeIfAbsent(patternString, Pattern::compile));
 
         int[] columnOrRow = isColumn
             ? image.getRGB(columnOrRowIndex, 0, 1, image.getHeight(), null, 0, 1)
@@ -47 +47 @@
         Matcher result = pattern.matcher(stringRepr);
 
         if (assertMatch && !result.matches()) {
-            System.err.println(String.format("Full strip failing to match pattern %s: %s", pattern, stringRepr));
+            System.err.printf("Full strip failing to match pattern %s: %s%n", pattern, stringRepr);
             fail(String.format(
                 "%s %d failed to match pattern %s",
                 isColumn ? "Column" : "Row",

test/unit/org/openstreetmap/josm/testutils/JOSMTestRules.java

@@ -664 +664 @@
         MainApplication.getLayerManager().resetState();
         try {
             eventManager.resetState();
-        } catch (IllegalArgumentException ignored) {
-            Logging.trace(ignored);
+        } catch (IllegalArgumentException e) {
+            Logging.trace(e);
         }
     }
 

test/unit/org/openstreetmap/josm/testutils/PluginServer.java

@@ -79 +79 @@
             if (srcJar != null) {
                 try {
                     jarFile = new JarFile(srcJar, false);
-                    jarFile.getManifest().getMainAttributes().entrySet().forEach(
-                        entry -> attrs.put(entry.getKey().toString(), entry.getValue().toString())
-                    );
+                    jarFile.getManifest().getMainAttributes()
+                            .forEach((key, value) -> attrs.put(key.toString(), value.toString()));
                 } catch (IOException e) {
                     Logging.warn(
                         "Failed to open {0} as a jar file. Using empty initial manifest. Error was: {1}",

test/unit/org/openstreetmap/josm/tools/template_engine/TemplateEntryTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.tools.template_engine;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.util.Set;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.TestUtils;
@@ -33 +34 @@
     void testEqualsContract() {
         TestUtils.assumeWorkingEqualsVerifier();
         Set<Class<? extends TemplateEntry>> templates = TestUtils.getJosmSubtypes(TemplateEntry.class);
-        Assert.assertTrue(templates.size() >= 3); // if it finds less than 3 classes, something is broken
+        assertTrue(templates.size() >= 3); // if it finds less than 3 classes, something is broken
         for (Class<?> c : templates) {
             Logging.debug(c.toString());
             EqualsVerifier.forClass(c).usingGetClass()

test/unit/org/openstreetmap/josm/tools/template_engine/TemplateParserTest.java

@@ -7 +7 @@
 import java.util.Arrays;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.JOSMFixture;
@@ -144 +143 @@
         TemplateEntry entry = parser.parse();
         StringBuilder sb = new StringBuilder();
         entry.appendText(sb, dataProvider);
-        Assert.assertEquals("waypointName uu i10i", sb.toString());
+        assertEquals("waypointName uu i10i", sb.toString());
     }
 
     /**
@@ -160 +159 @@
         Relation r = new Relation();
         r.put("admin_level", "2");
         templateEntry.appendText(sb, r);
-        Assert.assertEquals("NUTS 1", sb.toString());
+        assertEquals("NUTS 1", sb.toString());
 
         sb.setLength(0);
         r.put("admin_level", "5");
         templateEntry.appendText(sb, r);
-        Assert.assertEquals("5", sb.toString());
+        assertEquals("5", sb.toString());
     }
 
     /**
@@ -178 +177 @@
         TemplateEntry entry = parser.parse();
         StringBuilder sb = new StringBuilder();
         entry.appendText(sb, dataProvider);
-        Assert.assertEquals("name=waypointName, number=10", sb.toString());
-        Assert.assertEquals("{special:everything}", entry.toString());
+        assertEquals("name=waypointName, number=10", sb.toString());
+        assertEquals("{special:everything}", entry.toString());
     }
 
     /**
@@ -192 +191 @@
         TemplateEntry entry = parser.parse();
         StringBuilder sb = new StringBuilder();
         entry.appendText(sb, dataProvider);
-        Assert.assertEquals("waypointName\n10", sb.toString());
+        assertEquals("waypointName\n10", sb.toString());
     }
 
     /**
@@ -206 +205 @@
 
         StringBuilder sb = new StringBuilder();
         templateEntry.appendText(sb, dataProvider);
-        Assert.assertEquals("waypointNameulocalNameuspecialKey", sb.toString());
+        assertEquals("waypointNameulocalNameuspecialKey", sb.toString());
     }
 
     @Test
@@ -238 +237 @@
         TemplateEntry entry = parser.parse();
         entry.appendText(sb, child);
 
-        Assert.assertEquals("name_parent2", sb.toString());
+        assertEquals("name_parent2", sb.toString());
     }
 
     @Test
@@ -257 +256 @@
         TemplateEntry entry = parser.parse();
         entry.appendText(sb, child);
 
-        Assert.assertEquals("name_parent1", sb.toString());
+        assertEquals("name_parent1", sb.toString());
     }
 
     @Test
@@ -284 +283 @@
         entry.appendText(sb, child1);
         entry.appendText(sb, child2);
 
-        Assert.assertEquals("name_parent1name_parent2", sb.toString());
+        assertEquals("name_parent1name_parent2", sb.toString());
     }
 
     @Test
@@ -317 +316 @@
         entry.appendText(sb, child1);
         entry.appendText(sb, child2);
 
-        Assert.assertEquals("grandparent_namename_parent2", sb.toString());
+        assertEquals("grandparent_namename_parent2", sb.toString());
     }
 
     @Test
     void testErrorsNot() {
         TemplateParser parser = new TemplateParser("!{-parent() '{name}'}");
-        assertThrows(ParseError.class, () -> parser.parse());
+        assertThrows(ParseError.class, parser::parse);
     }
 
     @Test
     void testErrorOr() {
         TemplateParser parser = new TemplateParser("!{parent() | type=type1 '{name}'}");
-        assertThrows(ParseError.class, () -> parser.parse());
+        assertThrows(ParseError.class, parser::parse);
     }
 
     @Test
@@ -355 +354 @@
         TemplateEntry entry = parser.parse();
         entry.appendText(sb, parent2);
 
-        Assert.assertEquals("child2", sb.toString());
+        assertEquals("child2", sb.toString());
     }
 
     @Test
@@ -363 +362 @@
         final String s1 = "?{ '{name} ({desc})' | '{name} ({cmt})' | '{name}' | '{desc}' | '{cmt}' }";
         final String s2 = new TemplateParser(s1).parse().toString();
         final String s3 = new TemplateParser(s2).parse().toString();
-        Assert.assertEquals(s1, s2);
-        Assert.assertEquals(s2, s3);
+        assertEquals(s1, s2);
+        assertEquals(s2, s3);
     }
 }

test/unit/org/openstreetmap/josm/tools/AlphanumComparatorTest.java

@@ -4 +4 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 
 import org.junit.jupiter.api.Test;
@@ -20 +19 @@
     @Test
     void testNumeric() {
         List<String> lst = Arrays.asList("1", "20", "-1", "00999", "100");
-        Collections.sort(lst, AlphanumComparator.getInstance());
+        lst.sort(AlphanumComparator.getInstance());
         assertEquals(Arrays.asList("-1", "1", "20", "100", "00999"), lst);
     }
 
@@ -30 +29 @@
     @Test
     void testMixed() {
         List<String> lst = Arrays.asList("b1", "b20", "a5", "a00999", "a100");
-        Collections.sort(lst, AlphanumComparator.getInstance());
+        lst.sort(AlphanumComparator.getInstance());
         assertEquals(Arrays.asList("a5", "a100", "a00999", "b1", "b20"), lst);
     }
 }

test/unit/org/openstreetmap/josm/tools/GeometryTest.java

@@ -15 +15 @@
 import java.util.List;
 import java.util.stream.Stream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -71 +70 @@
 
         Double angle1 = Geometry.getCornerAngle(p1, p2, intersectionPoint);
         Double angle2 = Geometry.getCornerAngle(p3, p4, intersectionPoint);
-        Assert.assertTrue("intersection point not on line, angle: " + angle1,
-                Math.abs(angle1) < 1e-10);
-        Assert.assertTrue("intersection point not on line, angle: " + angle2,
-                Math.abs(angle1) < 1e-10);
+        assertTrue(Math.abs(angle1) < 1e-10, "intersection point not on line, angle: " + angle1);
+        assertTrue(Math.abs(angle1) < 1e-10, "intersection point not on line, angle: " + angle2);
 
-        Assert.assertTrue("cross product != 1 : " + Math.abs(crossProduct/len1/len2),
-                Math.abs(Math.abs(crossProduct/len1/len2) - 1) < 1e-10);
-        Assert.assertTrue("scalar product != 0 : " + scalarProduct/len1/len2,
-                Math.abs(scalarProduct/len1/len2) < 1e-10);
+        assertTrue(Math.abs(Math.abs(crossProduct/len1/len2) - 1) < 1e-10, "cross product != 1 : " + Math.abs(crossProduct/len1/len2));
+        assertTrue(Math.abs(scalarProduct/len1/len2) < 1e-10, "scalar product != 0 : " + scalarProduct/len1/len2);
     }
 
     /**
@@ -93 +88 @@
             DataSet ds = OsmReader.parseDataSet(in, null);
             Way closedWay = (Way) SubclassFilteredCollection.filter(ds.allPrimitives(),
                     SearchCompiler.compile("landuse=forest")).iterator().next();
-            Assert.assertEquals(5760015.7353515625, Geometry.closedWayArea(closedWay), 1e-3);
-            Assert.assertEquals(5760015.7353515625, Geometry.computeArea(closedWay), 1e-3);
+            assertEquals(5760015.7353515625, Geometry.closedWayArea(closedWay), 1e-3);
+            assertEquals(5760015.7353515625, Geometry.computeArea(closedWay), 1e-3);
         }
     }
 
@@ -108 +103 @@
         try (InputStream in = Files.newInputStream(Paths.get(TestUtils.getTestDataRoot(), "multipolygon.osm"))) {
             DataSet ds = OsmReader.parseDataSet(in, null);
             final Relation r = ds.getRelations().iterator().next();
-            Assert.assertEquals(4401735.20703125, Geometry.multipolygonArea(r), 1e-3);
-            Assert.assertEquals(4401735.20703125, Geometry.computeArea(r), 1e-3);
+            assertEquals(4401735.20703125, Geometry.multipolygonArea(r), 1e-3);
+            assertEquals(4401735.20703125, Geometry.computeArea(r), 1e-3);
         }
     }
 
@@ -125 +120 @@
             Way closedWay = (Way) SubclassFilteredCollection.filter(ds.allPrimitives(),
                     SearchCompiler.compile("landuse=forest")).iterator().next();
             Geometry.AreaAndPerimeter areaAndPerimeter = Geometry.getAreaAndPerimeter(closedWay.getNodes());
-            Assert.assertEquals(12495000., areaAndPerimeter.getArea(), 1e-3);
-            Assert.assertEquals(15093.201209424187, areaAndPerimeter.getPerimeter(), 1e-3);
+            assertEquals(12495000., areaAndPerimeter.getArea(), 1e-3);
+            assertEquals(15093.201209424187, areaAndPerimeter.getPerimeter(), 1e-3);
         }
     }
 
@@ -422 +417 @@
         Way way1 = TestUtils.newWay("", node1, node2, node3, node4);
 
         Way closestSegment = Geometry.getClosestWaySegment(way1, new Node(new LatLon(0, 0.5))).toWay();
-        Assert.assertTrue(closestSegment.containsNode(node1));
-        Assert.assertTrue(closestSegment.containsNode(node2));
+        assertTrue(closestSegment.containsNode(node1));
+        assertTrue(closestSegment.containsNode(node2));
     }
 
     /**

test/unit/org/openstreetmap/josm/tools/LanguageInfoTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.tools;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
@@ -58 +59 @@
         final List<String> actual = Stream.of(EN_NZ, DE_DE, PT_BR, CA_ES_VALENCIA, ZN_CN, ZN_TW, AST, EN_GB, RU, NB)
                 .map(locale -> LanguageInfo.getWikiLanguagePrefix(locale, type))
                 .collect(Collectors.toList());
-        Assert.assertEquals(Arrays.asList(expected), actual);
+        assertEquals(Arrays.asList(expected), actual);
     }
 
     /**
@@ -66 +67 @@
      */
     @Test
     void testGetLocale() {
-        Assert.assertEquals(RU, LanguageInfo.getLocale("ru"));
-        Assert.assertEquals(EN_GB, LanguageInfo.getLocale("en_GB"));
-        Assert.assertEquals(CA_ES_VALENCIA, LanguageInfo.getLocale("ca_ES@valencia"));
-        Assert.assertEquals(DE_DE, LanguageInfo.getLocale("de_DE"));
-        Assert.assertEquals(DE_DE, LanguageInfo.getLocale("de_DE.UTF-8")); // LANG, LC_MEASUREMENT
-        Assert.assertEquals(PT_BR, LanguageInfo.getLocale("pt_BR.UTF-8")); // LANG, LC_MEASUREMENT
+        assertEquals(RU, LanguageInfo.getLocale("ru"));
+        assertEquals(EN_GB, LanguageInfo.getLocale("en_GB"));
+        assertEquals(CA_ES_VALENCIA, LanguageInfo.getLocale("ca_ES@valencia"));
+        assertEquals(DE_DE, LanguageInfo.getLocale("de_DE"));
+        assertEquals(DE_DE, LanguageInfo.getLocale("de_DE.UTF-8")); // LANG, LC_MEASUREMENT
+        assertEquals(PT_BR, LanguageInfo.getLocale("pt_BR.UTF-8")); // LANG, LC_MEASUREMENT
     }
 
     /**
@@ -79 +80 @@
      */
     @Test
     void testGetJOSMLocaleCode() {
-        Assert.assertEquals("de", LanguageInfo.getJOSMLocaleCode(DE_DE));
-        Assert.assertEquals("pt_BR", LanguageInfo.getJOSMLocaleCode(PT_BR));
-        Assert.assertEquals("ca@valencia", LanguageInfo.getJOSMLocaleCode(CA_ES_VALENCIA));
+        assertEquals("de", LanguageInfo.getJOSMLocaleCode(DE_DE));
+        assertEquals("pt_BR", LanguageInfo.getJOSMLocaleCode(PT_BR));
+        assertEquals("ca@valencia", LanguageInfo.getJOSMLocaleCode(CA_ES_VALENCIA));
     }
 
     /**
@@ -89 +90 @@
      */
     @Test
     void testGetJavaLocaleCode() {
-        Assert.assertEquals("ca__valencia", LanguageInfo.getJavaLocaleCode("ca@valencia"));
+        assertEquals("ca__valencia", LanguageInfo.getJavaLocaleCode("ca@valencia"));
     }
 
     /**
@@ -97 +98 @@
      */
     @Test
     void testGetLanguageCodeXML() {
-        Assert.assertEquals("ca-valencia.", LanguageInfo.getLanguageCodeXML());
+        assertEquals("ca-valencia.", LanguageInfo.getLanguageCodeXML());
     }
 
     /**
@@ -105 +106 @@
      */
     @Test
     void testGetLanguageCodeManifest() {
-        Assert.assertEquals("ca-valencia_", LanguageInfo.getLanguageCodeManifest());
+        assertEquals("ca-valencia_", LanguageInfo.getLanguageCodeManifest());
     }
 
     /**
@@ -113 +114 @@
      */
     @Test
     void testGetLanguageCodes() {
-        Assert.assertEquals(Arrays.asList("ca_ES@valencia", "ca@valencia", "ca_ES", "ca"), LanguageInfo.getLanguageCodes(CA_ES_VALENCIA));
+        assertEquals(Arrays.asList("ca_ES@valencia", "ca@valencia", "ca_ES", "ca"), LanguageInfo.getLanguageCodes(CA_ES_VALENCIA));
     }
 }

test/unit/org/openstreetmap/josm/tools/MemoryManagerTest.java

@@ -64 +64 @@
         MemoryManager manager = MemoryManager.getInstance();
         MemoryHandle<Object> testMemory = manager.allocateMemory("test", 10, Object::new);
         testMemory.free();
-        assertThrows(IllegalStateException.class, () -> testMemory.get());
+        assertThrows(IllegalStateException.class, testMemory::get);
     }
 
     /**
@@ -76 +76 @@
         MemoryManager manager = MemoryManager.getInstance();
         MemoryHandle<Object> testMemory = manager.allocateMemory("test", 10, Object::new);
         testMemory.free();
-        assertThrows(IllegalStateException.class, () -> testMemory.free());
+        assertThrows(IllegalStateException.class, testMemory::free);
     }
 
     /**
@@ -153 +153 @@
         MemoryHandle<Object> testMemory = manager.allocateMemory("test", 10, Object::new);
 
         assertFalse(manager.resetState().isEmpty());
-        assertThrows(IllegalStateException.class, () -> testMemory.get());
+        assertThrows(IllegalStateException.class, testMemory::get);
     }
 
     /**

test/unit/org/openstreetmap/josm/tools/OsmUrlToBoundsTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.tools;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.openstreetmap.josm.data.Bounds;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -15 +16 @@
      */
     @Test
     void testPositionToBounds() {
-        Assert.assertEquals(new Bounds(51.7167359, 8.7573485, 51.720724, 8.7659315),
-                OsmUrlToBounds.positionToBounds(51.71873, 8.76164, 17));
-        Assert.assertEquals(new Bounds(40.8609329, -75.7523458, 40.8633671, -75.7480542),
-                OsmUrlToBounds.positionToBounds(40.86215, -75.75020, 18));
+        assertEquals(new Bounds(51.7167359, 8.7573485, 51.720724, 8.7659315), OsmUrlToBounds.positionToBounds(51.71873, 8.76164, 17));
+        assertEquals(new Bounds(40.8609329, -75.7523458, 40.8633671, -75.7480542), OsmUrlToBounds.positionToBounds(40.86215, -75.75020, 18));
     }
 
     /**
@@ -88 +87 @@
                 // Ignore. check if bounds is null after
                 Logging.trace(e);
             }
-            Assert.assertEquals(item.url, item.bounds, bounds);
+            assertEquals(item.bounds, bounds, item.url);
         }
     }
 
@@ -97 +96 @@
      */
     @Test
     void testGetZoom() {
-        Assert.assertEquals(4, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(0, 0, 4)));
-        Assert.assertEquals(10, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(5, 5, 10)));
-        Assert.assertEquals(18, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(40, 20, 18)));
+        assertEquals(4, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(0, 0, 4)));
+        assertEquals(10, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(5, 5, 10)));
+        assertEquals(18, OsmUrlToBounds.getZoom(OsmUrlToBounds.positionToBounds(40, 20, 18)));
     }
 }

test/unit/org/openstreetmap/josm/tools/Tag2LinkTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.tools;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
 
@@ -22 +24 @@
     }
 
     void checkLinks(String... expected) {
-        Assert.assertEquals(Arrays.asList(expected), links);
+        assertEquals(Arrays.asList(expected), links);
     }
 
     /**
@@ -31 +33 @@
     @Test
     void testInitialize() {
         Tag2Link.initialize();
-        Assert.assertTrue("obtains at least 40 rules", Tag2Link.wikidataRules.size() > 40);
+        assertTrue(Tag2Link.wikidataRules.size() > 40, "obtains at least 40 rules");
     }
 
     /**

test/unit/org/openstreetmap/josm/JOSMFixture.java

@@ -116 +116 @@
         pref.enableSaveOnPut(false);
         I18n.init();
         // initialize the platform hook, and
-        // call the really early hook before we anything else
+        // call the really early hook before anything else
         PlatformManager.getPlatform().preStartupHook();
 
         Logging.setLogLevel(Logging.LEVEL_INFO);
@@ -149 +149 @@
         DeleteCommand.setDeletionCallback(DeleteAction.defaultDeletionCallback);
 
         if (createGui) {
-            GuiHelper.runInEDTAndWaitWithException(() -> setupGUI());
+            GuiHelper.runInEDTAndWaitWithException(this::setupGUI);
         }
     }