changed InsertionEvaluatorTest to use routing functions that always return the same value given the same paramters

Author: hakoncarlsen

application/src/test/java/org/opentripplanner/ext/carpooling/routing/InsertionEvaluatorTest.java

@@ -20,7 +20,9 @@
 import static org.opentripplanner.ext.carpooling.TestCarpoolTripBuilder.createTripWithStops;
 
 import java.time.Duration;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.opentripplanner.astar.model.GraphPath;
@@ -31,6 +33,7 @@
 import org.opentripplanner.street.model.edge.Edge;
 import org.opentripplanner.street.model.vertex.Vertex;
 import org.opentripplanner.street.search.state.State;
+import org.opentripplanner.utils.collection.Pair;
 
 class InsertionEvaluatorTest {
 
@@ -106,14 +109,14 @@ void findOptimalInsertion_routingFails_skipsPosition() {
     // 1. Baseline calculation (2 segments: OSLO_CENTER → OSLO_EAST → OSLO_NORTH) = mockPath x2
     // 2. First insertion attempt fails (null for first segment)
     // 3. Second insertion attempt succeeds (mockPath for all segments)
-    final int[] callCount = { 0 };
+    @SuppressWarnings("ConstantConditions")
     RoutingFunction routingFunction = (from, to, linkingContext) -> {
-      int call = callCount[0]++;
-      if (call < 2) {
-        return mockPath;
-      } else if (call == 2) {
+      if(
+        new WgsCoordinate(from.lat, from.lng).equals(OSLO_CENTER) &&
+        new WgsCoordinate(to.lat, to.lng).equals(OSLO_MIDPOINT_NORTH)
+      ) {
         return null;
-      } else {
+      }else{
         return mockPath;
       }
     };
@@ -123,6 +126,11 @@ void findOptimalInsertion_routingFails_skipsPosition() {
 
     // Should skip failed routing and find a valid one
     assertNotNull(result);
+    /*
+      Since segment between OSLO_CENTER and OSLO_MIDPOINT_NORTH is invalid,
+      pickup position has to be after OSLO_EAST
+     */
+    assertEquals(2, result.pickupPosition());
   }
 
   @Test
@@ -173,42 +181,16 @@ void findOptimalInsertion_baselineDurationCalculationFails_returnsNull() {
   void findOptimalInsertion_selectsMinimumAdditionalDuration() {
     var trip = createTripWithDeviationBudget(Duration.ofMinutes(20), OSLO_CENTER, OSLO_NORTH);
 
-    // Baseline: 1 segment (CENTER → NORTH) at 10 min
-    // The algorithm will try multiple pickup/dropoff positions
-    // We'll return different durations based on segment index
-    var mockPath10 = createGraphPath(Duration.ofMinutes(10));
-    var mockPath4 = createGraphPath(Duration.ofMinutes(4));
-    var mockPath6 = createGraphPath(Duration.ofMinutes(6));
-    var mockPath5 = createGraphPath(Duration.ofMinutes(5));
-    var mockPath7 = createGraphPath(Duration.ofMinutes(7));
-
-    // Provide consistent route times
-    // Baseline
-    // First insertion (15 min total, 5 min additional)
-    // Second insertion (18 min total, 8 min additional)
-    @SuppressWarnings("unchecked")
-    final GraphPath<State, Edge, Vertex>[] firstInsertionPaths = new GraphPath[] {
-      mockPath4,
-      mockPath5,
-      mockPath6,
-    };
-    @SuppressWarnings("unchecked")
-    final GraphPath<State, Edge, Vertex>[] secondInsertionPaths = new GraphPath[] {
-      mockPath5,
-      mockPath6,
-      mockPath7,
-    };
-    final int[] callCount = { 0 };
-    RoutingFunction routingFunction = (from, to, linkingContext) -> {
-      int call = callCount[0]++;
-      if (call == 0) {
-        return mockPath10;
-      } else if (call >= 1 && call <= 3) {
-        return firstInsertionPaths[call - 1];
-      } else {
-        return secondInsertionPaths[(call - 4) % 3];
-      }
-    };
+    final Map<Pair<WgsCoordinate>, GraphPath<State, Edge, Vertex>> pathsMap = new HashMap<>(Map.of(
+      new Pair<>(OSLO_CENTER, OSLO_NORTH), createGraphPath(Duration.ofMinutes(10)),
+      new Pair<>(OSLO_CENTER, OSLO_EAST), createGraphPath(Duration.ofMinutes(4)),
+      new Pair<>(OSLO_EAST, OSLO_WEST), createGraphPath(Duration.ofMinutes(5)),
+      new Pair<>(OSLO_WEST, OSLO_NORTH), createGraphPath(Duration.ofMinutes(6))
+    ));
+
+    @SuppressWarnings("ConstantConditions")
+    RoutingFunction routingFunction = (from, to, linkingContext) ->
+      pathsMap.get(new Pair<>(new WgsCoordinate(from.lat, from.lng), new WgsCoordinate(to.lat, to.lng)));
 
     var result = findOptimalInsertion(trip, OSLO_EAST, OSLO_WEST, routingFunction);
 
@@ -259,24 +241,18 @@ void findOptimalInsertion_insertBetweenTwoPoints_routesAllSegments() {
     // MIDPOINT_NORTH → NORTH
     var segmentDB = createGraphPath(Duration.ofMinutes(4));
 
-    // Setup routing: return all segment mocks for any routing call
-    // The algorithm will evaluate multiple insertion positions
-    @SuppressWarnings("unchecked")
-    final GraphPath<State, Edge, Vertex>[] paths = new GraphPath[] {
-      baselinePath,
-      segmentAC,
-      segmentCD,
-      segmentDB,
-      segmentAC,
-      segmentCD,
-      segmentDB,
-      segmentAC,
-      segmentCD,
-    };
+    final Map<Pair<WgsCoordinate>, GraphPath<State, Edge, Vertex>> pathsMap = new HashMap<>(Map.of(
+      new Pair<>(OSLO_CENTER, OSLO_NORTH), baselinePath,
+      new Pair<>(OSLO_CENTER, OSLO_EAST), segmentAC,
+      new Pair<>(OSLO_EAST, OSLO_MIDPOINT_NORTH), segmentCD,
+      new Pair<>(OSLO_MIDPOINT_NORTH, OSLO_NORTH), segmentDB
+    ));
+
     final int[] callCount = { 0 };
+    @SuppressWarnings("ConstantConditions")
     RoutingFunction routingFunction = (from, to, linkingContext) -> {
-      int call = callCount[0]++;
-      return call < paths.length ? paths[call] : segmentAC;
+      callCount[0]++;
+      return pathsMap.get(new Pair<>(new WgsCoordinate(from.lat, from.lng), new WgsCoordinate(to.lat, to.lng)));
     };
 
     // Passenger pickup at OSLO_EAST, dropoff at OSLO_MIDPOINT_NORTH