Index: src/org/openstreetmap/josm/data/validation/tests/LongSegment.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/tests/LongSegment.java	(Revision 12028)
+++ src/org/openstreetmap/josm/data/validation/tests/LongSegment.java	(Arbeitskopie)
@@ -4,9 +4,16 @@
 import static org.openstreetmap.josm.tools.I18n.marktr;
 import static org.openstreetmap.josm.tools.I18n.tr;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.WaySegment;
 import org.openstreetmap.josm.data.validation.Severity;
 import org.openstreetmap.josm.data.validation.Test;
 import org.openstreetmap.josm.data.validation.TestError;
@@ -24,6 +31,8 @@
     /** Maximum segment length for this test */
     protected int maxlength;
 
+    protected Set<WaySegment> reported;
+
     /**
      * Constructor
      */
@@ -34,15 +43,63 @@
 
     @Override
     public void visit(Way w) {
-        if (w.hasTag("route", "ferry")) {
+        if (ignoreWay(w)) {
             return;
         }
-        Double length = w.getLongestSegmentLength();
-        if (length > maxlength) {
-            length /= 1000.0;
+        for (int i = 0; i < w.getNodesCount() - 1; i++) {
+            visitWaySegment(w, i);
+        }
+    }
+
+    @Override
+    public void visit(Node n) {
+        // Test all way segments around this node.
+        // If there is an error in the unchanged part of the way, we do not need to warn the user about it.
+
+        for (OsmPrimitive referrer : n.getReferrers()) {
+            if (!(referrer instanceof Way)) {
+                continue;
+            }
+            Way way = (Way) referrer;
+            if (ignoreWay(way)) {
+                continue;
+            }
+            // Do not simply use index of - a node may be in a way multiple times
+            for (int i = 0; i < way.getNodesCount(); i++) {
+                if (n == way.getNode(i)) {
+                    if (i > 0) {
+                        visitWaySegment(way, i - 1);
+                    }
+                    if (i < way.getNodesCount() - 1) {
+                        visitWaySegment(way, i);
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean ignoreWay(Way w) {
+        return w.hasTag("route", "ferry");
+    }
+
+    private void visitWaySegment(Way w, int i) {
+        LatLon coor1 = w.getNode(i).getCoor();
+        LatLon coor2 = w.getNode(i + 1).getCoor();
+
+        if (coor1 != null && coor2 != null) {
+            Double length = coor1.greatCircleDistance(coor2);
+            if (length > maxlength) {
+                addErrorForSegment(new WaySegment(w, i), length / 1000.0);
+            }
+        }
+    }
+
+    private void addErrorForSegment(WaySegment waySegment, Double length) {
+        if (reported.add(waySegment)) {
             errors.add(TestError.builder(this, Severity.WARNING, LONG_SEGMENT)
                     .message(tr("Long segments"), marktr("Very long segment of {0} kilometers"), length.intValue())
-                    .primitives(w)
+                    .primitives(waySegment.way)
+                    .highlightWaySegments(Collections.singleton(waySegment))
                     .build());
         }
     }
@@ -51,10 +108,26 @@
     public void startTest(ProgressMonitor monitor) {
         super.startTest(monitor);
         maxlength = Main.pref.getInteger("validator.maximum.segment.length", 15_000);
+        reported = Collections.synchronizedSet(new HashSet<>());
     }
 
     @Override
+    public void endTest() {
+        super.endTest();
+        // free memory
+        reported = null;
+    }
+
+    @Override
     public boolean isPrimitiveUsable(OsmPrimitive p) {
-        return p.isUsable() && p instanceof Way && ((Way) p).getNodesCount() > 1; // test only Ways with at least 2 nodes
+        if (!p.isUsable()) {
+            return false;
+        } else if (p instanceof Way && ((Way) p).getNodesCount() > 1) {
+            // test only Ways with at least 2 nodes
+            return true;
+        } else {
+            // test all nodes - ways referred by them may not be checked automatically.
+            return p instanceof Node;
+        }
     }
 }