Index: trunk/test/unit/org/openstreetmap/josm/data/osm/WayTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/osm/WayTest.java	(revision 18551)
+++ trunk/test/unit/org/openstreetmap/josm/data/osm/WayTest.java	(revision 18553)
@@ -8,4 +8,5 @@
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 
@@ -49,7 +50,7 @@
         Way way = new Way(1);
         assertFalse(way.getBBox().isValid());
-        way.setNodes(Arrays.asList(n1));
+        way.setNodes(Collections.singletonList(n1));
         assertFalse(way.getBBox().isValid());
-        way.setNodes(Arrays.asList(n2));
+        way.setNodes(Collections.singletonList(n2));
         assertTrue(way.getBBox().isValid());
         way.setNodes(Arrays.asList(n1, n2));
@@ -116,5 +117,5 @@
         assertEquals(Arrays.asList(n1, n2, n1), way.getNodes());
         way.setNodes(Arrays.asList(n1, n2, n3, n4, n1));
-        way.removeNodes(new HashSet<>(Arrays.asList(n1)));
+        way.removeNodes(new HashSet<>(Collections.singletonList(n1)));
         assertEquals(Arrays.asList(n2, n3, n4, n2), way.getNodes());
     }
@@ -135,3 +136,27 @@
         assertThrows(IllegalArgumentException.class, () -> new Way().load(new NodeData()));
     }
+
+    @Test
+    void getLongestSegmentLength() {
+        DataSet ds = new DataSet();
+        Node n1 = new Node(1);
+        Node n2 = new Node(2);
+        Node n3 = new Node(3);
+        Node n4 = new Node(4);
+        n1.setCoor(new LatLon(0.01, 0.01));
+        n2.setCoor(new LatLon(0.02, 0.02));
+        n3.setCoor(new LatLon(0.03, 0.03));
+        n4.setCoor(new LatLon(0.05, 0.05));
+        ds.addPrimitive(n1);
+        ds.addPrimitive(n2);
+        ds.addPrimitive(n3);
+        ds.addPrimitive(n4);
+        Way way = new Way(1);
+        ds.addPrimitive(way);
+
+        assertEquals(0.0, way.getLongestSegmentLength());
+        way.setNodes(Arrays.asList(n1, n2, n2, n3, n4));
+
+        assertEquals(3148.5902810874577, way.getLongestSegmentLength());
+    }
 }
Index: trunk/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java	(revision 18553)
+++ trunk/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java	(revision 18553)
@@ -0,0 +1,121 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+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;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.TagMap;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
+
+/**
+ * Test class for {@link PowerLines}
+ * @since 18553
+ */
+@BasicPreferences
+class PowerLinesTest {
+    private PowerLines powerLines;
+    private DataSet ds;
+
+    @RegisterExtension
+    static JOSMTestRules josmTestRules = new JOSMTestRules().projection();
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        ds = new DataSet();
+
+        powerLines = new PowerLines();
+        powerLines.initialize();
+        powerLines.startTest(null);
+    }
+
+    @Test
+    void testNoBreakInLine() {
+        Way powerline = new Way();
+        powerline.setKeys(new TagMap("power", "line"));
+        ds.addPrimitive(powerline);
+
+        for (int i = 0; i < 10; i++) {
+            Node node = new Node(new LatLon(0, 0.001 * i));
+            node.setKeys(new TagMap("power", "tower"));
+            ds.addPrimitive(node);
+            powerline.addNode(node);
+        }
+        powerLines.visit(powerline);
+        powerLines.endTest();
+        assertTrue(powerLines.getErrors().isEmpty());
+    }
+
+    @Test
+    void testBreakInLine() {
+        Way powerline = new Way();
+        powerline.setKeys(new TagMap("power", "line"));
+        ds.addPrimitive(powerline);
+
+        for (int i = 0; i < 10; i++) {
+            if (i != 4 && i != 5) {
+                Node node = new Node(new LatLon(0, 0.001 * i));
+                node.setKeys(new TagMap("power", "tower"));
+                ds.addPrimitive(node);
+                powerline.addNode(node);
+            }
+        }
+        powerLines.visit(powerline);
+        powerLines.endTest();
+        assertFalse(powerLines.getErrors().isEmpty());
+    }
+
+    @Test
+    void testConnectionAndRefInLine() {
+        Way powerline = new Way();
+        powerline.setKeys(new TagMap("power", "line"));
+        ds.addPrimitive(powerline);
+
+        int connectionCount = 0;
+
+        for (int i = 0; i < 10; i++) {
+            Node node = new Node(new LatLon(0, 0.001 * i));
+            node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i)));
+            if (i == 4 || i == 5) {
+                node.setKeys(new TagMap("power", "connection"));
+                connectionCount++;
+            }
+            if (i > 5) {
+                node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i - connectionCount)));
+            }
+            ds.addPrimitive(node);
+            powerline.addNode(node);
+        }
+        powerLines.visit(powerline);
+        powerLines.endTest();
+        assertTrue(powerLines.getErrors().isEmpty());
+    }
+
+    @Test
+    void testRefDiscontinuityInLine() {
+        Way powerline = new Way();
+        powerline.setKeys(new TagMap("power", "minor_line"));
+        ds.addPrimitive(powerline);
+
+        for (int i = 0; i < 10; i++) {
+            Node node = new Node(new LatLon(0, 0.001 * i));
+            node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i)));
+            if (i < 4) {
+                // add discontinuity
+                node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i + 1)));
+            }
+            ds.addPrimitive(node);
+            powerline.addNode(node);
+        }
+        powerLines.visit(powerline);
+        powerLines.endTest();
+        assertFalse(powerLines.getErrors().isEmpty());
+    }
+}
Index: trunk/test/unit/org/openstreetmap/josm/tools/UtilsTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/tools/UtilsTest.java	(revision 18551)
+++ trunk/test/unit/org/openstreetmap/josm/tools/UtilsTest.java	(revision 18553)
@@ -128,5 +128,5 @@
     @Test
     void testPositionListString() {
-        assertEquals("1", Utils.getPositionListString(Arrays.asList(1)));
+        assertEquals("1", Utils.getPositionListString(Collections.singletonList(1)));
         assertEquals("1-2", Utils.getPositionListString(Arrays.asList(1, 2)));
         assertEquals("1-3", Utils.getPositionListString(Arrays.asList(1, 2, 3)));
@@ -251,5 +251,5 @@
     @Test
     void testJoinAsHtmlUnorderedList() {
-        List<? extends Object> items = Arrays.asList("1", Integer.valueOf(2));
+        List<?> items = Arrays.asList("1", 2);
         assertEquals("<ul><li>1</li><li>2</li></ul>", Utils.joinAsHtmlUnorderedList(items));
         assertEquals("<ul></ul>", Utils.joinAsHtmlUnorderedList(Collections.emptyList()));
@@ -532,3 +532,16 @@
         assertEquals("Hello World", output);
     }
+
+    /**
+     * Test of {@link Utils#getStandardDeviation(double[])} and {@link Utils#getStandardDeviation(double[], double)}
+     */
+    @Test
+    void testGetStandardDeviation() {
+        assertEquals(0.0, Utils.getStandardDeviation(new double[]{1, 1, 1, 1}));
+        assertEquals(0.0, Utils.getStandardDeviation(new double[]{1, 1, 1, 1}, 1.0));
+        assertEquals(0.5, Utils.getStandardDeviation(new double[]{1, 1, 2, 2}));
+
+        assertEquals(-1.0, Utils.getStandardDeviation(new double[]{}));
+        assertEquals(-1.0, Utils.getStandardDeviation(new double[]{0}));
+    }
 }