Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java
===================================================================
--- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java	(revision 32740)
+++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java	(revision 32741)
@@ -241,4 +241,6 @@
 		for (int i = 1; i < manager.getPTStopCount(); i++) {
 
+			this.firstNodeOfRouteSegmentInDirectionOfTravel = null;
+
 			PTStop startStop = manager.getPTStops().get(i - 1);
 			PTStop endStop = manager.getPTStops().get(i);
@@ -250,8 +252,4 @@
 				continue;
 			}
-//
-//			System.out.println();
-//			System.out.println("start way: " + startWay.getId());
-//			System.out.println("end way: " + endWay.getId());
 
 			List<PTWay> segmentWays = manager.getPTWaysBetween(startWay, endWay);
@@ -264,4 +262,21 @@
 						segmentWays.get(0));
 				if (this.firstNodeOfRouteSegmentInDirectionOfTravel == null) {
+					// check if this error has just been reported:
+					TestError previousError = this.errors.get(this.errors.size() - 1);
+					if (previousError.getHighlighted().size() == 1
+							&& previousError.getHighlighted().iterator().next() == startWay) {
+						// do nothing, this error has already been reported in
+						// the previous step
+					} else {
+						List<Relation> primitives = new ArrayList<>(1);
+						primitives.add(relation);
+						List<OsmPrimitive> highlighted = new ArrayList<>();
+						highlighted.add(startWay);
+						TestError e = new TestError(this.test, Severity.WARNING, tr("PT: Problem in the route segment"),
+								PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP, primitives, highlighted);
+						this.errors.add(e);
+						PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays);
+						wrongSegments.put(e, routeSegment);
+					}
 					continue;
 				}
@@ -274,5 +289,4 @@
 				correctSegments.add(routeSegment);
 			} else {
-//				System.out.println("ERROR");
 				PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays);
 				TestError error = this.errors.get(this.errors.size() - 1);
@@ -320,5 +334,18 @@
 			return null;
 		}
+		PTWay wayAfterNext = manager.getNextPTWay(nextWay);
 		Node[] nextWayEndnodes = nextWay.getEndNodes();
+		if ((startWayEndnodes[0] == nextWayEndnodes[0] && startWayEndnodes[1] == nextWayEndnodes[1])
+				|| (startWayEndnodes[0] == nextWayEndnodes[1] && startWayEndnodes[1] == nextWayEndnodes[0])) {
+			// if this is a split roundabout:
+			Node[] wayAfterNextEndnodes = wayAfterNext.getEndNodes();
+			if (startWayEndnodes[0] == wayAfterNextEndnodes[0] || startWayEndnodes[0] == wayAfterNextEndnodes[1]) {
+				return startWayEndnodes[0];
+			}
+			if (startWayEndnodes[1] == wayAfterNextEndnodes[0] || startWayEndnodes[1] == wayAfterNextEndnodes[1]) {
+				return startWayEndnodes[1];
+			}
+		}
+
 		if (startWayEndnodes[0] == nextWayEndnodes[0] || startWayEndnodes[0] == nextWayEndnodes[1]) {
 			return startWayEndnodes[1];
@@ -370,4 +397,16 @@
 	}
 
+	/**
+	 * Checks if the existing sorting of the given route segment is correct
+	 * 
+	 * @param start
+	 *            PTWay assigned to the first stop of the segment
+	 * @param startWayPreviousNodeInDirectionOfTravel
+	 *            Node if the start way which is furthest away from the rest of
+	 *            the route
+	 * @param end
+	 *            PTWay assigned to the end stop of the segment
+	 * @return true if the sorting is correct, false otherwise.
+	 */
 	private boolean existingWaySortingIsCorrect(PTWay start, Node startWayPreviousNodeInDirectionOfTravel, PTWay end) {
 
@@ -406,18 +445,6 @@
 				// find the next node in direction of travel (which is part of
 				// the PTWay start):
-//				if (firstNodeOfRouteSegmentInDirectionOfTravel != null) {
-//					System.out.println("previous node in direction of travel: "
-//							+ firstNodeOfRouteSegmentInDirectionOfTravel.getId());
-//				} else {
-//					System.out.println("previous node in direction of travel: null");
-//				}
 				firstNodeOfRouteSegmentInDirectionOfTravel = getOppositeEndNode(current,
 						firstNodeOfRouteSegmentInDirectionOfTravel);
-//				if (firstNodeOfRouteSegmentInDirectionOfTravel != null) {
-//					System.out.println(
-//							"next node in direction of travel: " + firstNodeOfRouteSegmentInDirectionOfTravel.getId());
-//				} else {
-//					System.out.println("next node in direction of travel: null");
-//				}
 
 				List<PTWay> nextWaysInDirectionOfTravel = this.findNextPTWaysInDirectionOfTravel(current,
@@ -528,26 +555,60 @@
 	protected static boolean isFixable(TestError testError) {
 
+		/*-
+		 * When is an error fixable?
+		 * - if there is a correct segment
+		 * - if it can be fixed by sorting
+		 * - if the route is compete even without some ways
+		 * - if simple routing closes the gap
+		 */
+
 		if (testError.getCode() == PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP) {
-
-			PTRouteSegment wrongSegment = wrongSegments.get(testError);
-			PTRouteSegment correctSegment = null;
-			// TODO: now just the first correctSegment is taken over. Change
-			// that
-			// the segment is selected.
-			for (PTRouteSegment segment : correctSegments) {
-				if (wrongSegment.getFirstStop().equalsStop(segment.getFirstStop())
-						&& wrongSegment.getLastStop().equalsStop(segment.getLastStop())) {
-					correctSegment = segment;
-					// System.out.println("correct segment found: " +
-					// correctSegment.getFirstStop().getPlatform().getId());
-					break;
-				}
-			}
-
-			return correctSegment != null;
+			if (isFixableByUsingCorrectSegment(testError)) {
+				return true;
+			}
+			if (isFixableBySegmentSorting(testError)) {
+				return true;
+			}
+			if (isFixableByRemovingWays()) {
+				return true;
+			}
+			if (isFixableBySimpleRouting()) {
+				return true;
+			}
 		}
 
 		return false;
 
+	}
+
+	private static boolean isFixableByUsingCorrectSegment(TestError testError) {
+		PTRouteSegment wrongSegment = wrongSegments.get(testError);
+		PTRouteSegment correctSegment = null;
+		// TODO: now just the first correctSegment is taken over. Change
+		// that the segment is selected.
+		for (PTRouteSegment segment : correctSegments) {
+			if (wrongSegment.getFirstStop().equalsStop(segment.getFirstStop())
+					&& wrongSegment.getLastStop().equalsStop(segment.getLastStop())) {
+				correctSegment = segment;
+				break;
+			}
+		}
+		return correctSegment != null;
+	}
+
+	private static boolean isFixableBySegmentSorting(TestError testError) {
+		PTRouteSegment wrongSegment = wrongSegments.get(testError);
+
+		return false;
+	}
+
+	private static boolean isFixableByRemovingWays() {
+		// TODO
+		return false;
+	}
+
+	private static boolean isFixableBySimpleRouting() {
+		// TODO
+		return false;
 	}