Index: trunk/test/unit/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculatorTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculatorTest.java	(revision 15073)
+++ trunk/test/unit/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculatorTest.java	(revision 15076)
@@ -8,4 +8,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 
@@ -15,5 +17,8 @@
 import org.junit.Test;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
 import org.openstreetmap.josm.io.IllegalDataException;
@@ -131,3 +136,119 @@
         Assert.assertEquals("[BACKWARD, BACKWARD, BACKWARD, FPH FORWARD, FPH FORWARD, FPH FORWARD, FPH FORWARD]", actual);
     }
+
+    private void reverseWay(Way way) {
+        List<Node> nodes = way.getNodes();
+        Collections.reverse(nodes);
+        way.removeNodes(new HashSet<>(nodes));
+        for (Node node : nodes) {
+            way.addNode(node);
+        }
+    }
+
+    /**
+     * Test directional {@link WayConnectionTypeCalculator#computeNextWayConnection}
+     */
+    @Test
+    public void testDirectionsOnewaysOnly() {
+        Relation relation = getRelation("direction");
+
+        // 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);
+        }
+
+        Assert.assertTrue(returned.get(4).onewayFollowsPrevious);
+        Assert.assertFalse(returned.get(4).onewayFollowsNext);
+
+        Assert.assertFalse(returned.get(5).onewayFollowsPrevious);
+        Assert.assertFalse(returned.get(5).onewayFollowsNext);
+
+        Assert.assertFalse(returned.get(6).onewayFollowsPrevious);
+        Assert.assertTrue(returned.get(6).onewayFollowsNext);
+
+        // Reverse the last oneway
+        OsmPrimitive way7 = relation.getMemberPrimitivesList().get(6);
+        if (way7 instanceof Way) {
+            Way way = (Way) way7;
+            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);
+            }
+
+            Assert.assertTrue(returned.get(4).onewayFollowsPrevious);
+            Assert.assertFalse(returned.get(4).onewayFollowsNext);
+
+            Assert.assertFalse(returned.get(5).onewayFollowsPrevious);
+            Assert.assertTrue(returned.get(5).onewayFollowsNext);
+
+            Assert.assertTrue(returned.get(6).onewayFollowsPrevious);
+            Assert.assertTrue(returned.get(6).onewayFollowsNext);
+            reverseWay(way);
+        }
+
+        // Reverse the wrong oneway
+        OsmPrimitive way6 = relation.getMemberPrimitivesList().get(5);
+        if (way6 instanceof Way) {
+            Way way = (Way) way6;
+            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);
+            }
+        }
+
+        // Reverse everything
+        for (Way way : relation.getMemberPrimitives(Way.class)) {
+            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);
+        }
+    }
+
+    /**
+     * Test directional {@link WayConnectionTypeCalculator#computeNextWayConnection}
+     */
+    @Test
+    public void testDirectionsOnewayMix() {
+        Relation relation = getRelation("direction");
+
+        // Remove the oneway in the wrong direction
+        OsmPrimitive osm = relation.getMemberPrimitivesList().get(5);
+        osm.remove("oneway");
+        List<WayConnectionType> returned = wayConnectionTypeCalculator.updateLinks(relation.getMembers());
+        for (WayConnectionType type : returned) {
+            Assert.assertTrue(type.onewayFollowsNext);
+            Assert.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);
+        }
+
+        // Check with oneways that converge onto a two-way
+        // TODO figure out a way to find this situation?
+        osm.remove("oneway");
+        OsmPrimitive way7 = relation.getMemberPrimitivesList().get(6);
+        way7.put("oneway", "-1");
+        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);
+        }
+        Assert.assertTrue(returned.get(6).onewayFollowsNext);
+        Assert.assertFalse(returned.get(6).onewayFollowsPrevious);
+    }
 }