core: pathfinding: reproduce edge case in a test + fix

Author: eckter

core/src/main/java/fr/sncf/osrd/api/pathfinding/PathfindingBlocksEndpoint.java

@@ -323,9 +323,12 @@ private void assertPathTracksAreComplete(List<RJSDirectionalTrackRange> tracksOn
         while (i < tracksOnPath.size()) {
             var track = tracksOnPath.get(i);
             var trackName = track.trackSectionID;
-            var fullTrack = new ArrayList<>(tracksOnPath.stream()
-                    .filter(trackOnPath -> Objects.equals(trackOnPath.trackSectionID, track.trackSectionID))
-                    .toList());
+            var fullTrack = new ArrayList<RJSDirectionalTrackRange>();
+            for (int j = i; j < tracksOnPath.size(); j++) {
+                if (!trackName.equals(tracksOnPath.get(j).trackSectionID))
+                    break;
+                fullTrack.add(tracksOnPath.get(j));
+            }
             var fullTrackLength =
                     toMeters(rawInfra.getTrackSectionLength(getTrackSectionFromNameOrThrow(trackName, rawInfra)));
 

core/src/main/java/fr/sncf/osrd/utils/graph/Pathfinding.java

@@ -169,28 +169,29 @@ public Result<EdgeT> runPathfinding(
             seen.put(step.range, step.nReachedTargets);
             if (hasReachedEnd(targetsOnEdges.size(), step))
                 return buildResult(step);
-            // Check if the next target is reached in this step
-            for (var target : targetsOnEdges.get(step.nReachedTargets).apply(step.range.edge))
-                if (step.range.start <= target.offset) {
-                    // Adds a new step precisely on the stop location. This ensures that we don't ignore the
-                    // distance between the start of the edge and the stop location
-                    var newRange = new EdgeRange<>(target.edge, step.range.start, target.offset);
-                    newRange = filterRange(newRange);
-                    assert newRange != null;
-                    if (newRange.end != target.offset) {
-                        // The target location is blocked by a blocked range, it can't be accessed from here
-                        continue;
+            // Check if the next target is reached in this step, only if the step doesn't already reach a step
+            if (step.prev == null || step.nReachedTargets == step.prev.nReachedTargets)
+                for (var target : targetsOnEdges.get(step.nReachedTargets).apply(step.range.edge))
+                    if (step.range.start <= target.offset) {
+                        // Adds a new step precisely on the stop location. This ensures that we don't ignore the
+                        // distance between the start of the edge and the stop location
+                        var newRange = new EdgeRange<>(target.edge, step.range.start, target.offset);
+                        newRange = filterRange(newRange);
+                        assert newRange != null;
+                        if (newRange.end != target.offset) {
+                            // The target location is blocked by a blocked range, it can't be accessed from here
+                            continue;
+                        }
+                        var stepTargets = new ArrayList<>(step.targets);
+                        stepTargets.add(target);
+                        registerStep(
+                                newRange,
+                                step.prev,
+                                step.totalDistance,
+                                step.nReachedTargets + 1,
+                                stepTargets
+                        );
                     }
-                    var stepTargets = new ArrayList<>(step.targets);
-                    stepTargets.add(target);
-                    registerStep(
-                            newRange,
-                            step.prev,
-                            step.totalDistance,
-                            step.nReachedTargets + 1,
-                            stepTargets
-                    );
-                }
             var edgeLength = edgeToLength.apply(step.range.edge);
             if (step.range.end == edgeLength) {
                 // We reach the end of the edge: we visit neighbors

core/src/test/java/fr/sncf/osrd/utils/graph/PathfindingTests.java

@@ -263,6 +263,28 @@ public void noPathTest() {
         assertNull(res);
     }
 
+    @Test
+    public void noPathTestSameEdge() {
+        /* No possible path without going backwards, with several steps on the last edge
+
+        0 -> B -> 1 -> 2 -> E2 -> E1 -> 3
+         */
+        var builder = new SimpleGraphBuilder();
+        builder.makeNodes(4);
+        builder.makeEdge(0, 1, 100);
+        builder.makeEdge(1, 2, 100);
+        builder.makeEdge(2, 3, 100);
+        var g = builder.build();
+        var res = new Pathfinding<>(g)
+                .setEdgeToLength(edge -> edge.length)
+                .runPathfindingEdgesOnly(List.of(
+                        List.of(builder.getEdgeLocation("0-1")),
+                        List.of(builder.getEdgeLocation("2-3", 20)),
+                        List.of(builder.getEdgeLocation("2-3", 10))
+                ));
+        assertNull(res);
+    }
+
     @Test
     public void sameEdgeNoPathTest() {
         /* The end is on the same edge but at a smaller offset that the start: no path