{
@Nonnull
public String serialize(@Nonnull Object input) throws CoercingSerializeException {
if (input instanceof Duration duration) {
- return duration.toString();
+ return DurationUtils.formatDurationWithLeadingMinus(duration);
}
throw new CoercingSerializeException(input + " cannot be cast to 'Duration'");
diff --git a/src/main/java/org/opentripplanner/framework/io/OtpHttpClient.java b/src/main/java/org/opentripplanner/framework/io/OtpHttpClient.java
index 72b67441a18..c922cfcc4be 100644
--- a/src/main/java/org/opentripplanner/framework/io/OtpHttpClient.java
+++ b/src/main/java/org/opentripplanner/framework/io/OtpHttpClient.java
@@ -138,6 +138,7 @@ private OtpHttpClient(Duration timeout, Duration connectionTtl, int maxConnectio
HttpClientBuilder httpClientBuilder = HttpClients
.custom()
+ .setUserAgent("OpenTripPlanner")
.setConnectionManager(connectionManager)
.setDefaultRequestConfig(requestConfig(timeout));
diff --git a/src/main/java/org/opentripplanner/framework/lang/StringUtils.java b/src/main/java/org/opentripplanner/framework/lang/StringUtils.java
index cbb32b9eaca..9eff448d0c7 100644
--- a/src/main/java/org/opentripplanner/framework/lang/StringUtils.java
+++ b/src/main/java/org/opentripplanner/framework/lang/StringUtils.java
@@ -1,5 +1,6 @@
package org.opentripplanner.framework.lang;
+import java.util.regex.Pattern;
import javax.annotation.Nonnull;
/**
@@ -7,6 +8,18 @@
*/
public class StringUtils {
+ /**
+ * Regex to find unprintable characters like newlines and 'ZERO WIDTH SPACE' (U+200B).
+ *
+ * \p{C} was chosen over \p{Cntrl} because it also recognises invisible control characters in the
+ * middle of a word.
+ */
+ private static final String INVISIBLE_CHARS_REGEX = "\\p{C}";
+ /**
+ * Patterns are immutable and thread safe.
+ */
+ private static final Pattern INVISIBLE_CHARS_PATTERN = Pattern.compile(INVISIBLE_CHARS_REGEX);
+
private StringUtils() {}
/** true if the given text is not {@code null} or has at least one none white-space character. */
@@ -119,4 +132,14 @@ public static String quoteReplace(@Nonnull String text) {
public static String kebabCase(String input) {
return input.toLowerCase().replace('_', '-');
}
+
+ /**
+ * Detects unprintable control characters like newlines, tabs and invisible whitespace
+ * like 'ZERO WIDTH SPACE' (U+200B) that don't have an immediate visual representation.
+ *
+ * Note that "regular" whitespace characters like U+0020 and U+2000 are considered visible.
+ */
+ public static boolean containsInvisibleCharacters(String input) {
+ return INVISIBLE_CHARS_PATTERN.matcher(input).find();
+ }
}
diff --git a/src/main/java/org/opentripplanner/framework/time/DurationUtils.java b/src/main/java/org/opentripplanner/framework/time/DurationUtils.java
index bf59964fbb2..9a01d308a1c 100644
--- a/src/main/java/org/opentripplanner/framework/time/DurationUtils.java
+++ b/src/main/java/org/opentripplanner/framework/time/DurationUtils.java
@@ -196,4 +196,22 @@ public static int toIntMilliseconds(Duration timeout, int defaultValue) {
private static String msToSecondsStr(String formatSeconds, double timeMs) {
return String.format(ROOT, formatSeconds, timeMs / 1000.0) + " seconds";
}
+
+ /**
+ * Formats a duration and if it's a negative amount, it places the minus before the "P" rather
+ * than in the middle of the value.
+ *
+ * Background: There are multiple ways to express -1.5 hours: "PT-1H-30M" and "-PT1H30M".
+ *
+ * The first version is what you get when calling toString() but it's quite confusing. Therefore,
+ * this method makes sure that you get the second form "-PT1H30M".
+ */
+ public static String formatDurationWithLeadingMinus(Duration duration) {
+ if (duration.isNegative()) {
+ var positive = duration.abs().toString();
+ return "-" + positive;
+ } else {
+ return duration.toString();
+ }
+ }
}
diff --git a/src/main/java/org/opentripplanner/framework/time/OffsetDateTimeParser.java b/src/main/java/org/opentripplanner/framework/time/OffsetDateTimeParser.java
new file mode 100644
index 00000000000..8b40697977a
--- /dev/null
+++ b/src/main/java/org/opentripplanner/framework/time/OffsetDateTimeParser.java
@@ -0,0 +1,42 @@
+package org.opentripplanner.framework.time;
+
+import java.text.ParseException;
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+
+public class OffsetDateTimeParser {
+
+ /**
+ * We need to have two offsets, in order to parse both "+0200" and "+02:00". The first is not
+ * really ISO-8601 compatible with the extended date and time. We need to make parsing strict, in
+ * order to keep the minute mandatory, otherwise we would be left with an unparsed minute
+ */
+ public static final DateTimeFormatter LENIENT_PARSER = new DateTimeFormatterBuilder()
+ .parseCaseInsensitive()
+ .parseLenient()
+ .append(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
+ .optionalStart()
+ .parseStrict()
+ .appendOffset("+HH:MM:ss", "Z")
+ .parseLenient()
+ .optionalEnd()
+ .optionalStart()
+ .appendOffset("+HHmmss", "Z")
+ .optionalEnd()
+ .toFormatter();
+
+ /**
+ * Parses a ISO-8601 string into am OffsetDateTime instance allowing the offset to be both in
+ * '02:00' and '0200' format.
+ * @throws ParseException if the string cannot be parsed
+ */
+ public static OffsetDateTime parseLeniently(CharSequence input) throws ParseException {
+ try {
+ return OffsetDateTime.parse(input, LENIENT_PARSER);
+ } catch (DateTimeParseException e) {
+ throw new ParseException(e.getParsedString(), e.getErrorIndex());
+ }
+ }
+}
diff --git a/src/main/java/org/opentripplanner/gtfs/graphbuilder/GtfsModule.java b/src/main/java/org/opentripplanner/gtfs/graphbuilder/GtfsModule.java
index cf9d48c64c5..2f7feb5993e 100644
--- a/src/main/java/org/opentripplanner/gtfs/graphbuilder/GtfsModule.java
+++ b/src/main/java/org/opentripplanner/gtfs/graphbuilder/GtfsModule.java
@@ -120,12 +120,20 @@ public void buildGraph() {
boolean hasTransit = false;
+ Map feedIdsEncountered = new HashMap<>();
+
try {
for (GtfsBundle gtfsBundle : gtfsBundles) {
GtfsMutableRelationalDao gtfsDao = loadBundle(gtfsBundle);
+
+ final String feedId = gtfsBundle.getFeedId().getId();
+ verifyUniqueFeedId(gtfsBundle, feedIdsEncountered, feedId);
+
+ feedIdsEncountered.put(feedId, gtfsBundle);
+
GTFSToOtpTransitServiceMapper mapper = new GTFSToOtpTransitServiceMapper(
new OtpTransitServiceBuilder(transitModel.getStopModel(), issueStore),
- gtfsBundle.getFeedId().getId(),
+ feedId,
issueStore,
gtfsBundle.discardMinTransferTimes(),
gtfsDao,
@@ -203,6 +211,32 @@ public void buildGraph() {
transitModel.updateCalendarServiceData(hasTransit, calendarServiceData, issueStore);
}
+ /**
+ * Verifies that a feed id is not assigned twice.
+ *
+ * Duplicates can happen in the following cases:
+ * - the feed id is configured twice in build-config.json
+ * - two GTFS feeds have the same feed_info.feed_id
+ * - a GTFS feed defines a feed_info.feed_id like '3' that collides with an auto-generated one
+ *
+ * Debugging these cases is very confusing, so we prevent it from happening.
+ */
+ private static void verifyUniqueFeedId(
+ GtfsBundle gtfsBundle,
+ Map feedIdsEncountered,
+ String feedId
+ ) {
+ if (feedIdsEncountered.containsKey(feedId)) {
+ LOG.error(
+ "Feed id '{}' has been used for {} but it was already assigned to {}.",
+ feedId,
+ gtfsBundle,
+ feedIdsEncountered.get(feedId)
+ );
+ throw new IllegalArgumentException("Duplicate feed id: '%s'".formatted(feedId));
+ }
+ }
+
@Override
public void checkInputs() {
for (GtfsBundle bundle : gtfsBundles) {
diff --git a/src/main/java/org/opentripplanner/model/plan/FrequencyTransitLeg.java b/src/main/java/org/opentripplanner/model/plan/FrequencyTransitLeg.java
index d2188fb1b0b..48c4b1b7b87 100644
--- a/src/main/java/org/opentripplanner/model/plan/FrequencyTransitLeg.java
+++ b/src/main/java/org/opentripplanner/model/plan/FrequencyTransitLeg.java
@@ -1,16 +1,9 @@
package org.opentripplanner.model.plan;
-import java.time.LocalDate;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.Nullable;
import org.opentripplanner.framework.time.ServiceDateUtils;
-import org.opentripplanner.model.transfer.ConstrainedTransfer;
-import org.opentripplanner.transit.model.network.TripPattern;
import org.opentripplanner.transit.model.site.StopLocation;
-import org.opentripplanner.transit.model.timetable.TripTimes;
/**
* One leg of a trip -- that is, a temporally continuous piece of the journey that takes place on a
@@ -62,8 +55,8 @@ public List getIntermediateStops() {
StopArrival visit = new StopArrival(
Place.forStop(stop),
- ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, arrivalTime),
- ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, departureTime),
+ LegTime.ofStatic(ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, arrivalTime)),
+ LegTime.ofStatic(ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, departureTime)),
i,
tripTimes.gtfsSequenceOfStopIndex(i)
);
diff --git a/src/main/java/org/opentripplanner/model/plan/Leg.java b/src/main/java/org/opentripplanner/model/plan/Leg.java
index 05213dbdf5e..5a032def979 100644
--- a/src/main/java/org/opentripplanner/model/plan/Leg.java
+++ b/src/main/java/org/opentripplanner/model/plan/Leg.java
@@ -200,6 +200,16 @@ default Accessibility getTripWheelchairAccessibility() {
return null;
}
+ /**
+ * The time (including realtime information) when the leg starts.
+ */
+ LegTime start();
+
+ /**
+ * The time (including realtime information) when the leg ends.
+ */
+ LegTime end();
+
/**
* The date and time this leg begins.
*/
diff --git a/src/main/java/org/opentripplanner/model/plan/LegTime.java b/src/main/java/org/opentripplanner/model/plan/LegTime.java
new file mode 100644
index 00000000000..354ce4f4b0b
--- /dev/null
+++ b/src/main/java/org/opentripplanner/model/plan/LegTime.java
@@ -0,0 +1,45 @@
+package org.opentripplanner.model.plan;
+
+import java.time.Duration;
+import java.time.ZonedDateTime;
+import java.util.Objects;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * A scheduled time of a transit vehicle at a certain location with a optional realtime information.
+ */
+public record LegTime(@Nonnull ZonedDateTime scheduledTime, @Nullable RealTimeEstimate estimated) {
+ public LegTime {
+ Objects.requireNonNull(scheduledTime);
+ }
+
+ @Nonnull
+ public static LegTime of(ZonedDateTime realtime, int delaySecs) {
+ var delay = Duration.ofSeconds(delaySecs);
+ return new LegTime(realtime.minus(delay), new RealTimeEstimate(realtime, delay));
+ }
+
+ @Nonnull
+ public static LegTime ofStatic(ZonedDateTime staticTime) {
+ return new LegTime(staticTime, null);
+ }
+
+ /**
+ * The most up-to-date time available: if realtime data is available it is returned, if not then
+ * the scheduled one is.
+ */
+ public ZonedDateTime time() {
+ if (estimated == null) {
+ return scheduledTime;
+ } else {
+ return estimated.time;
+ }
+ }
+
+ /**
+ * Realtime information about a vehicle at a certain place.
+ * @param delay Delay or "earliness" of a vehicle. Earliness is expressed as a negative number.
+ */
+ record RealTimeEstimate(ZonedDateTime time, Duration delay) {}
+}
diff --git a/src/main/java/org/opentripplanner/model/plan/ScheduledTransitLeg.java b/src/main/java/org/opentripplanner/model/plan/ScheduledTransitLeg.java
index 876567035dd..6bf39d5aa4c 100644
--- a/src/main/java/org/opentripplanner/model/plan/ScheduledTransitLeg.java
+++ b/src/main/java/org/opentripplanner/model/plan/ScheduledTransitLeg.java
@@ -162,6 +162,24 @@ public Accessibility getTripWheelchairAccessibility() {
return tripTimes.getWheelchairAccessibility();
}
+ @Override
+ public LegTime start() {
+ if (getRealTime()) {
+ return LegTime.of(startTime, getDepartureDelay());
+ } else {
+ return LegTime.ofStatic(startTime);
+ }
+ }
+
+ @Override
+ public LegTime end() {
+ if (getRealTime()) {
+ return LegTime.of(endTime, getArrivalDelay());
+ } else {
+ return LegTime.ofStatic(endTime);
+ }
+ }
+
@Override
@Nonnull
public TransitMode getMode() {
@@ -257,17 +275,11 @@ public Place getTo() {
@Override
public List getIntermediateStops() {
List visits = new ArrayList<>();
+ var mapper = new StopArrivalMapper(zoneId, serviceDate, tripTimes);
for (int i = boardStopPosInPattern + 1; i < alightStopPosInPattern; i++) {
StopLocation stop = tripPattern.getStop(i);
-
- StopArrival visit = new StopArrival(
- Place.forStop(stop),
- ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, tripTimes.getArrivalTime(i)),
- ServiceDateUtils.toZonedDateTime(serviceDate, zoneId, tripTimes.getDepartureTime(i)),
- i,
- tripTimes.gtfsSequenceOfStopIndex(i)
- );
+ final StopArrival visit = mapper.map(i, stop, getRealTime());
visits.add(visit);
}
return visits;
diff --git a/src/main/java/org/opentripplanner/model/plan/StopArrival.java b/src/main/java/org/opentripplanner/model/plan/StopArrival.java
index 10398768c85..489b122da09 100644
--- a/src/main/java/org/opentripplanner/model/plan/StopArrival.java
+++ b/src/main/java/org/opentripplanner/model/plan/StopArrival.java
@@ -1,39 +1,31 @@
package org.opentripplanner.model.plan;
-import java.time.ZonedDateTime;
import org.opentripplanner.framework.tostring.ToStringBuilder;
/**
* This class is used to represent a stop arrival event mostly for intermediate visits to a stops
* along a route.
*/
-public class StopArrival {
+public final class StopArrival {
public final Place place;
- /**
- * The time the rider will arrive at the place.
- */
- public final ZonedDateTime arrival;
-
- /**
- * The time the rider will depart the place.
- */
- public final ZonedDateTime departure;
-
- /**
- * For transit trips, the stop index (numbered from zero from the start of the trip).
- */
+ public final LegTime arrival;
+ public final LegTime departure;
public final Integer stopPosInPattern;
+ public final Integer gtfsStopSequence;
/**
- * For transit trips, the sequence number of the stop. Per GTFS, these numbers are increasing.
+ * @param arrival The time the rider will arrive at the place.
+ * @param departure The time the rider will depart the place.
+ * @param stopPosInPattern For transit trips, the stop index (numbered from zero from the start of
+ * the trip).
+ * @param gtfsStopSequence For transit trips, the sequence number of the stop. Per GTFS, these
+ * numbers are increasing.
*/
- public final Integer gtfsStopSequence;
-
public StopArrival(
Place place,
- ZonedDateTime arrival,
- ZonedDateTime departure,
+ LegTime arrival,
+ LegTime departure,
Integer stopPosInPattern,
Integer gtfsStopSequence
) {
@@ -48,8 +40,8 @@ public StopArrival(
public String toString() {
return ToStringBuilder
.of(StopArrival.class)
- .addTime("arrival", arrival)
- .addTime("departure", departure)
+ .addObj("arrival", arrival)
+ .addObj("departure", departure)
.addObj("place", place)
.toString();
}
diff --git a/src/main/java/org/opentripplanner/model/plan/StopArrivalMapper.java b/src/main/java/org/opentripplanner/model/plan/StopArrivalMapper.java
new file mode 100644
index 00000000000..25bab2a7c3f
--- /dev/null
+++ b/src/main/java/org/opentripplanner/model/plan/StopArrivalMapper.java
@@ -0,0 +1,53 @@
+package org.opentripplanner.model.plan;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Objects;
+import org.opentripplanner.framework.time.ServiceDateUtils;
+import org.opentripplanner.transit.model.site.StopLocation;
+import org.opentripplanner.transit.model.timetable.TripTimes;
+
+/**
+ * Maps leg-related information to an instance of {@link StopArrival}.
+ */
+class StopArrivalMapper {
+
+ private final ZoneId zoneId;
+ private final LocalDate serviceDate;
+ private final TripTimes tripTimes;
+
+ public StopArrivalMapper(ZoneId zoneId, LocalDate serviceDate, TripTimes tripTimes) {
+ this.zoneId = Objects.requireNonNull(zoneId);
+ this.serviceDate = Objects.requireNonNull(serviceDate);
+ this.tripTimes = Objects.requireNonNull(tripTimes);
+ }
+
+ StopArrival map(int i, StopLocation stop, boolean realTime) {
+ final var arrivalTime = ServiceDateUtils.toZonedDateTime(
+ serviceDate,
+ zoneId,
+ tripTimes.getArrivalTime(i)
+ );
+ final var departureTime = ServiceDateUtils.toZonedDateTime(
+ serviceDate,
+ zoneId,
+ tripTimes.getDepartureTime(i)
+ );
+
+ var arrival = LegTime.ofStatic(arrivalTime);
+ var departure = LegTime.ofStatic(departureTime);
+
+ if (realTime) {
+ arrival = LegTime.of(arrivalTime, tripTimes.getArrivalDelay(i));
+ departure = LegTime.of(departureTime, tripTimes.getDepartureDelay(i));
+ }
+
+ return new StopArrival(
+ Place.forStop(stop),
+ arrival,
+ departure,
+ i,
+ tripTimes.gtfsSequenceOfStopIndex(i)
+ );
+ }
+}
diff --git a/src/main/java/org/opentripplanner/model/plan/StreetLeg.java b/src/main/java/org/opentripplanner/model/plan/StreetLeg.java
index 319c9e01f69..6384159a4ec 100644
--- a/src/main/java/org/opentripplanner/model/plan/StreetLeg.java
+++ b/src/main/java/org/opentripplanner/model/plan/StreetLeg.java
@@ -156,6 +156,16 @@ public boolean hasSameMode(Leg other) {
return other instanceof StreetLeg oSL && mode.equals(oSL.mode);
}
+ @Override
+ public LegTime start() {
+ return LegTime.ofStatic(startTime);
+ }
+
+ @Override
+ public LegTime end() {
+ return LegTime.ofStatic(endTime);
+ }
+
@Override
public Leg withTimeShift(Duration duration) {
return StreetLegBuilder
diff --git a/src/main/java/org/opentripplanner/model/plan/UnknownTransitPathLeg.java b/src/main/java/org/opentripplanner/model/plan/UnknownTransitPathLeg.java
index 382a09d34e2..df43bbcb411 100644
--- a/src/main/java/org/opentripplanner/model/plan/UnknownTransitPathLeg.java
+++ b/src/main/java/org/opentripplanner/model/plan/UnknownTransitPathLeg.java
@@ -68,6 +68,16 @@ public boolean hasSameMode(Leg other) {
return false;
}
+ @Override
+ public LegTime start() {
+ return LegTime.ofStatic(startTime);
+ }
+
+ @Override
+ public LegTime end() {
+ return LegTime.ofStatic(endTime);
+ }
+
@Override
public double getDistanceMeters() {
return UNKNOWN;
diff --git a/src/main/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPaths.java b/src/main/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPaths.java
index d070a804f9c..66b7227584d 100644
--- a/src/main/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPaths.java
+++ b/src/main/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPaths.java
@@ -194,7 +194,7 @@ private List filterOnTimePenaltyLimitIfExist(List e.timePenalty() > iterationTimePenaltyLimit).toList();
}
return list;
diff --git a/src/main/java/org/opentripplanner/routing/algorithm/mapping/AlertToLegMapper.java b/src/main/java/org/opentripplanner/routing/algorithm/mapping/AlertToLegMapper.java
index dd08ab6095d..94630be7600 100644
--- a/src/main/java/org/opentripplanner/routing/algorithm/mapping/AlertToLegMapper.java
+++ b/src/main/java/org/opentripplanner/routing/algorithm/mapping/AlertToLegMapper.java
@@ -91,8 +91,8 @@ public void addTransitAlertsToLeg(Leg leg, boolean isFirstLeg) {
)
);
- ZonedDateTime stopArrival = visit.arrival;
- ZonedDateTime stopDeparture = visit.departure;
+ ZonedDateTime stopArrival = visit.arrival.scheduledTime();
+ ZonedDateTime stopDeparture = visit.departure.scheduledTime();
addTransitAlertsToLeg(leg, alerts, stopArrival, stopDeparture);
}
diff --git a/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelope.java b/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelope.java
index 8d211fd33db..27a1fb4d30f 100644
--- a/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelope.java
+++ b/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelope.java
@@ -6,8 +6,7 @@
import org.opentripplanner.framework.tostring.ToStringBuilder;
/**
- * This class calculates borders of envelopes that can be also on 180th meridian The same way as it
- * was previously calculated in GraphMetadata constructor
+ * This class calculates borders of envelopes that can be also on 180th meridian.
*/
public class WorldEnvelope implements Serializable {
@@ -53,14 +52,6 @@ public WgsCoordinate upperRight() {
return upperRight;
}
- /**
- * This is the center of the Envelope including both street vertexes and transit stops
- * if they exist.
- */
- public WgsCoordinate meanCenter() {
- return meanCenter;
- }
-
/**
* If transit data exist, then this is the median center of the transit stops. The median
* is computed independently for the longitude and latitude.
@@ -68,13 +59,21 @@ public WgsCoordinate meanCenter() {
* If not transit data exist this return `empty`.
*/
public WgsCoordinate center() {
- return transitMedianCenter().orElse(meanCenter);
+ return medianCenter().orElse(meanCenter);
+ }
+
+ /**
+ * This is the center of the Envelope including both street vertexes and transit stops
+ * if they exist.
+ */
+ public WgsCoordinate meanCenter() {
+ return meanCenter;
}
/**
* Return the transit median center [if it exist] or the mean center.
*/
- public Optional transitMedianCenter() {
+ public Optional medianCenter() {
return Optional.ofNullable(transitMedianCenter);
}
diff --git a/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeBuilder.java b/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeBuilder.java
index abddba9c5fd..7c5bf13d5e5 100644
--- a/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeBuilder.java
+++ b/src/main/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeBuilder.java
@@ -58,8 +58,23 @@ public WorldEnvelopeBuilder expandToIncludeTransitEntities(
var medianCalculator = new MedianCalcForDoubles(collection.size());
- collection.forEach(v -> medianCalculator.add(lonProvider.apply(v)));
- double lon = medianCalculator.median();
+ double lon = 0.0;
+ if (includeLongitude180()) {
+ collection.forEach(v -> {
+ double c = lonProvider.apply(v);
+ if (c < 0) {
+ c += 360.0;
+ }
+ medianCalculator.add(c);
+ });
+ lon = medianCalculator.median();
+ if (lon > 180.0) {
+ lon -= 180;
+ }
+ } else {
+ collection.forEach(v -> medianCalculator.add(lonProvider.apply(v)));
+ lon = medianCalculator.median();
+ }
medianCalculator.reset();
collection.forEach(v -> medianCalculator.add(latProvider.apply(v)));
@@ -79,19 +94,26 @@ public WorldEnvelope build() {
if (minLonEast == MIN_NOT_SET) {
return new WorldEnvelope(minLat, minLonWest, maxLat, maxLonWest, transitMedianCenter);
}
- // Envelope intersects with either 0º or 180º
- double dist0 = minLonEast - minLonWest;
- double dist180 = 360d - maxLonEast + minLonWest;
-
- // A small gap between the east and west longitude at 0 degrees implies that the Envelope
- // should include the 0 degrees longitude(meridian), and be split at 180 degrees.
- if (dist0 < dist180) {
- return new WorldEnvelope(minLat, maxLonWest, maxLat, maxLonEast, transitMedianCenter);
- } else {
+ if (includeLongitude180()) {
return new WorldEnvelope(minLat, minLonEast, maxLat, minLonWest, transitMedianCenter);
+ } else {
+ return new WorldEnvelope(minLat, minLonWest, maxLat, maxLonEast, transitMedianCenter);
}
}
+ /**
+ * A small gap between the east and west longitude at 180º degrees implies that the Envelope
+ * should include the 180º longitude, and be split at 0 degrees.
+ */
+ boolean includeLongitude180() {
+ if (minLonWest == MIN_NOT_SET || minLonEast == MIN_NOT_SET) {
+ return false;
+ }
+ double dist0 = minLonEast - minLonWest;
+ double dist180 = 360d - maxLonEast + minLonWest;
+ return dist180 < dist0;
+ }
+
private WorldEnvelopeBuilder expandToInclude(double latitude, double longitude) {
minLat = Math.min(minLat, latitude);
maxLat = Math.max(maxLat, latitude);
diff --git a/src/main/java/org/opentripplanner/transit/model/framework/FeedScopedId.java b/src/main/java/org/opentripplanner/transit/model/framework/FeedScopedId.java
index d67ccc3d0e1..b48ff040c28 100644
--- a/src/main/java/org/opentripplanner/transit/model/framework/FeedScopedId.java
+++ b/src/main/java/org/opentripplanner/transit/model/framework/FeedScopedId.java
@@ -5,9 +5,9 @@
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
-import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+import org.opentripplanner.framework.lang.StringUtils;
public final class FeedScopedId implements Serializable, Comparable {
@@ -59,7 +59,17 @@ public static FeedScopedId parse(String value) throws IllegalArgumentException {
* Parses a string consisting of concatenated FeedScopedIds to a List
*/
public static List parseList(String s) {
- return Arrays.stream(s.split(",")).map(FeedScopedId::parse).collect(Collectors.toList());
+ if (StringUtils.containsInvisibleCharacters(s)) {
+ throw new IllegalArgumentException(
+ "The input string '%s' contains invisible characters which is not allowed.".formatted(s)
+ );
+ }
+ return Arrays
+ .stream(s.split(","))
+ .map(String::strip)
+ .filter(i -> !i.isBlank())
+ .map(FeedScopedId::parse)
+ .toList();
}
public static boolean isValidString(String value) throws IllegalArgumentException {
diff --git a/src/main/resources/org/opentripplanner/apis/gtfs/schema.graphqls b/src/main/resources/org/opentripplanner/apis/gtfs/schema.graphqls
index daeb57d655e..c1189f21ba1 100644
--- a/src/main/resources/org/opentripplanner/apis/gtfs/schema.graphqls
+++ b/src/main/resources/org/opentripplanner/apis/gtfs/schema.graphqls
@@ -1497,15 +1497,11 @@ type DefaultFareProduct implements FareProduct {
}
type Itinerary {
- """
- Time when the user leaves from the origin. Format: Unix timestamp in milliseconds.
- """
- startTime: Long
+ "Time when the user leaves from the origin."
+ start: OffsetDateTime
- """
- Time when the user arrives to the destination.. Format: Unix timestamp in milliseconds.
- """
- endTime: Long
+ "Time when the user leaves arrives at the destination."
+ end: OffsetDateTime
"""Duration of the trip on this itinerary, in seconds."""
duration: Long
@@ -1584,6 +1580,16 @@ type Itinerary {
and always returns an empty list. Use the leg's `fareProducts` instead.
"""
fares: [fare] @deprecated(reason: "Use the leg's `fareProducts`.")
+
+ """
+ Time when the user leaves from the origin. Format: Unix timestamp in milliseconds.
+ """
+ startTime: Long @deprecated(reason: "Use `start` instead which includes timezone information.")
+
+ """
+ Time when the user arrives to the destination. Format: Unix timestamp in milliseconds.
+ """
+ endTime: Long @deprecated(reason: "Use `end` instead which includes timezone information.")
}
"A currency"
@@ -1616,10 +1622,12 @@ type Money {
amount: Float!
}
-""""
+"""
An ISO-8601-formatted duration, i.e. `PT2H30M` for 2 hours and 30 minutes.
+
+Negative durations are formatted like `-PT10M`.
"""
-scalar Duration
+scalar Duration @specifiedBy(url:"https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/time/Duration.html#parse(java.lang.CharSequence)")
type RideHailingProvider {
"The ID of the ride hailing provider."
@@ -1640,30 +1648,46 @@ type RideHailingEstimate {
productName: String
}
-type Leg {
- """
- The date and time when this leg begins. Format: Unix timestamp in milliseconds.
- """
- startTime: Long
+"""
+An ISO-8601-formatted datetime with offset, i.e. `2023-06-13T14:30+03:00` for 2:30pm on June 13th 2023 at Helsinki's offset from UTC at that time.
+
+ISO-8601 allows many different formats but OTP will only return the profile specified in RFC3339.
+"""
+scalar OffsetDateTime @specifiedBy(url: "https://www.rfcreader.com/#rfc3339")
+"Real-time estimates for a vehicle at a certain place."
+type RealTimeEstimate {
+ time: OffsetDateTime!
"""
- The date and time when this leg ends. Format: Unix timestamp in milliseconds.
+ The delay or "earliness" of the vehicle at a certain place.
+
+ If the vehicle is early then this is a negative duration.
"""
- endTime: Long
+ delay: Duration!
+}
+
+"""
+Time information about a passenger at a certain place. May contain real-time information if
+available.
+"""
+type LegTime {
+ "The scheduled time of the event."
+ scheduledTime: OffsetDateTime!
+ "The estimated time of the event. If no real-time information is available, this is null,"
+ estimated: RealTimeEstimate
+}
+
+type Leg {
"""
- For transit leg, the offset from the scheduled departure time of the boarding
- stop in this leg, i.e. scheduled time of departure at boarding stop =
- `startTime - departureDelay`
+ The time when the leg starts including real-time information, if available.
"""
- departureDelay: Int
+ start: LegTime!
"""
- For transit leg, the offset from the scheduled arrival time of the alighting
- stop in this leg, i.e. scheduled time of arrival at alighting stop = `endTime
- - arrivalDelay`
+ The time when the leg ends including real-time information, if available.
"""
- arrivalDelay: Int
+ end: LegTime!
"""The mode (e.g. `WALK`) used when traversing this leg."""
mode: Mode
@@ -1825,6 +1849,31 @@ type Leg {
that applies to multiple legs can appear several times.
"""
fareProducts: [FareProductUse]
+
+ """
+ The date and time when this leg begins. Format: Unix timestamp in milliseconds.
+ """
+ startTime: Long @deprecated(reason: "Use `start.estimated.time` instead which contains timezone information.")
+
+ """
+ The date and time when this leg ends. Format: Unix timestamp in milliseconds.
+ """
+ endTime: Long @deprecated(reason: "Use `end.estimated.time` instead which contains timezone information.")
+
+ """
+ For transit leg, the offset from the scheduled departure time of the boarding
+ stop in this leg, i.e. scheduled time of departure at boarding stop =
+ `startTime - departureDelay`
+ """
+ departureDelay: Int @deprecated(reason: "Use `end.estimated.delay` instead.")
+
+ """
+ For transit leg, the offset from the scheduled arrival time of the alighting
+ stop in this leg, i.e. scheduled time of arrival at alighting stop = `endTime
+ - arrivalDelay`
+ """
+ arrivalDelay: Int @deprecated(reason: "Use `start.estimated.delay` instead.")
+
}
"""A span of time."""
@@ -2260,14 +2309,16 @@ type Place {
lon: Float!
"""
- The time the rider will arrive at the place. Format: Unix timestamp in milliseconds.
+ The time the rider will arrive at the place. This also includes real-time information
+ if available.
"""
- arrivalTime: Long!
+ arrival: LegTime
"""
- The time the rider will depart the place. Format: Unix timestamp in milliseconds.
+ The time the rider will depart the place. This also includes real-time information
+ if available.
"""
- departureTime: Long!
+ departure: LegTime
"""The stop related to the place."""
stop: Stop
@@ -2305,6 +2356,16 @@ type Place {
"""The car parking related to the place"""
carPark: CarPark @deprecated(reason: "carPark is deprecated. Use vehicleParking instead.")
+
+ """
+ The time the rider will arrive at the place. Format: Unix timestamp in milliseconds.
+ """
+ arrivalTime: Long! @deprecated(reason: "Use `arrival` which includes timezone information.")
+
+ """
+ The time the rider will depart the place. Format: Unix timestamp in milliseconds.
+ """
+ departureTime: Long! @deprecated(reason: "Use `departure` which includes timezone information.")
}
type placeAtDistance implements Node {
diff --git a/src/test/java/org/opentripplanner/apis/gtfs/DurationScalarTest.java b/src/test/java/org/opentripplanner/apis/gtfs/DurationScalarTest.java
new file mode 100644
index 00000000000..28d1ad08376
--- /dev/null
+++ b/src/test/java/org/opentripplanner/apis/gtfs/DurationScalarTest.java
@@ -0,0 +1,41 @@
+package org.opentripplanner.apis.gtfs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.params.provider.Arguments.of;
+
+import graphql.schema.CoercingSerializeException;
+import java.time.Duration;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class DurationScalarTest {
+
+ static List durationCases() {
+ return List.of(
+ of(Duration.ofMinutes(30), "PT30M"),
+ of(Duration.ofHours(23), "PT23H"),
+ of(Duration.ofMinutes(-10), "-PT10M"),
+ of(Duration.ofMinutes(-90), "-PT1H30M"),
+ of(Duration.ofMinutes(-184), "-PT3H4M")
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("durationCases")
+ void duration(Duration duration, String expected) {
+ var string = GraphQLScalars.DURATION_SCALAR.getCoercing().serialize(duration);
+ assertEquals(expected, string);
+ }
+
+ @Test
+ void nonDuration() {
+ Assertions.assertThrows(
+ CoercingSerializeException.class,
+ () -> GraphQLScalars.DURATION_SCALAR.getCoercing().serialize(new Object())
+ );
+ }
+}
diff --git a/src/test/java/org/opentripplanner/apis/gtfs/GraphQLScalarsTest.java b/src/test/java/org/opentripplanner/apis/gtfs/GeoJsonScalarTest.java
similarity index 59%
rename from src/test/java/org/opentripplanner/apis/gtfs/GraphQLScalarsTest.java
rename to src/test/java/org/opentripplanner/apis/gtfs/GeoJsonScalarTest.java
index 90b35a31b9f..cc88e22d074 100644
--- a/src/test/java/org/opentripplanner/apis/gtfs/GraphQLScalarsTest.java
+++ b/src/test/java/org/opentripplanner/apis/gtfs/GeoJsonScalarTest.java
@@ -3,29 +3,12 @@
import static org.junit.jupiter.api.Assertions.assertEquals;
import com.fasterxml.jackson.core.JsonProcessingException;
-import graphql.schema.CoercingSerializeException;
-import java.time.Duration;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.GeometryFactory;
import org.opentripplanner.framework.json.ObjectMappers;
-class GraphQLScalarsTest {
-
- @Test
- void duration() {
- var string = GraphQLScalars.durationScalar.getCoercing().serialize(Duration.ofMinutes(30));
- assertEquals("PT30M", string);
- }
-
- @Test
- void nonDuration() {
- Assertions.assertThrows(
- CoercingSerializeException.class,
- () -> GraphQLScalars.durationScalar.getCoercing().serialize(new Object())
- );
- }
+class GeoJsonScalarTest {
@Test
void geoJson() throws JsonProcessingException {
@@ -38,7 +21,7 @@ void geoJson() throws JsonProcessingException {
new Coordinate(0, 0),
}
);
- var geoJson = GraphQLScalars.geoJsonScalar.getCoercing().serialize(polygon);
+ var geoJson = GraphQLScalars.GEOJSON_SCALAR.getCoercing().serialize(polygon);
var jsonNode = ObjectMappers
.ignoringExtraFields()
diff --git a/src/test/java/org/opentripplanner/apis/gtfs/GraphQLIntegrationTest.java b/src/test/java/org/opentripplanner/apis/gtfs/GraphQLIntegrationTest.java
index d89afea6f9d..f630e0cee3c 100644
--- a/src/test/java/org/opentripplanner/apis/gtfs/GraphQLIntegrationTest.java
+++ b/src/test/java/org/opentripplanner/apis/gtfs/GraphQLIntegrationTest.java
@@ -61,7 +61,6 @@
import org.opentripplanner.routing.alertpatch.TimePeriod;
import org.opentripplanner.routing.alertpatch.TransitAlert;
import org.opentripplanner.routing.api.request.RouteRequest;
-import org.opentripplanner.routing.core.FareType;
import org.opentripplanner.routing.graph.Graph;
import org.opentripplanner.routing.graphfinder.GraphFinder;
import org.opentripplanner.routing.graphfinder.NearbyStop;
@@ -86,6 +85,7 @@
import org.opentripplanner.transit.model.network.TripPattern;
import org.opentripplanner.transit.model.site.RegularStop;
import org.opentripplanner.transit.model.site.StopLocation;
+import org.opentripplanner.transit.model.timetable.RealTimeTripTimes;
import org.opentripplanner.transit.model.timetable.TripTimesFactory;
import org.opentripplanner.transit.service.DefaultTransitService;
import org.opentripplanner.transit.service.TransitModel;
@@ -115,6 +115,7 @@ class GraphQLIntegrationTest {
.parse("2023-02-15T12:03:28+01:00")
.toInstant();
static final Instant ALERT_END_TIME = ALERT_START_TIME.plus(1, ChronoUnit.DAYS);
+ private static final int TEN_MINUTES = 10 * 60;
private static GraphQLRequestContext context;
@@ -179,6 +180,8 @@ static void setup() {
.carHail(D10m, E)
.build();
+ add10MinuteDelay(i1);
+
var busLeg = i1.getTransitLeg(1);
var railLeg = (ScheduledTransitLeg) i1.getTransitLeg(2);
@@ -280,6 +283,20 @@ public TransitAlertService getTransitAlertService() {
);
}
+ private static void add10MinuteDelay(Itinerary i1) {
+ i1.transformTransitLegs(tl -> {
+ if (tl instanceof ScheduledTransitLeg stl) {
+ var rtt = (RealTimeTripTimes) stl.getTripTimes();
+
+ for (var i = 0; i < rtt.getNumStops(); i++) {
+ rtt.updateArrivalTime(i, rtt.getArrivalTime(i) + TEN_MINUTES);
+ rtt.updateDepartureTime(i, rtt.getDepartureTime(i) + TEN_MINUTES);
+ }
+ }
+ return tl;
+ });
+ }
+
@FilePatternSource(pattern = "src/test/resources/org/opentripplanner/apis/gtfs/queries/*.graphql")
@ParameterizedTest(name = "Check GraphQL query in {0}")
void graphQL(Path path) throws IOException {
diff --git a/src/test/java/org/opentripplanner/apis/gtfs/OffsetDateTimeScalarTest.java b/src/test/java/org/opentripplanner/apis/gtfs/OffsetDateTimeScalarTest.java
new file mode 100644
index 00000000000..45c8e9de837
--- /dev/null
+++ b/src/test/java/org/opentripplanner/apis/gtfs/OffsetDateTimeScalarTest.java
@@ -0,0 +1,62 @@
+package org.opentripplanner.apis.gtfs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.params.provider.Arguments.of;
+
+import graphql.language.StringValue;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.opentripplanner._support.time.ZoneIds;
+
+public class OffsetDateTimeScalarTest {
+
+ static final OffsetDateTime OFFSET_DATE_TIME = OffsetDateTime.of(
+ LocalDate.of(2024, 2, 4),
+ LocalTime.MIDNIGHT,
+ ZoneOffset.UTC
+ );
+
+ static List offsetDateTimeCases() {
+ return List.of(
+ of(OFFSET_DATE_TIME, "2024-02-04T00:00:00Z"),
+ of(OFFSET_DATE_TIME.plusHours(12).plusMinutes(8).plusSeconds(22), "2024-02-04T12:08:22Z"),
+ of(
+ OFFSET_DATE_TIME.atZoneSameInstant(ZoneIds.BERLIN).toOffsetDateTime(),
+ "2024-02-04T01:00:00+01:00"
+ ),
+ of(
+ OFFSET_DATE_TIME.atZoneSameInstant(ZoneIds.NEW_YORK).toOffsetDateTime(),
+ "2024-02-03T19:00:00-05:00"
+ )
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("offsetDateTimeCases")
+ void serializeOffsetDateTime(OffsetDateTime odt, String expected) {
+ var string = GraphQLScalars.OFFSET_DATETIME_SCALAR.getCoercing().serialize(odt);
+ assertEquals(expected, string);
+ }
+
+ @ParameterizedTest
+ @MethodSource("offsetDateTimeCases")
+ void parseOffsetDateTime(OffsetDateTime expected, String input) {
+ var odt = GraphQLScalars.OFFSET_DATETIME_SCALAR.getCoercing().parseValue(input);
+ assertEquals(expected, odt);
+ }
+
+ @ParameterizedTest
+ @MethodSource("offsetDateTimeCases")
+ void parseOffsetDateTimeLiteral(OffsetDateTime expected, String input) {
+ var odt = GraphQLScalars.OFFSET_DATETIME_SCALAR
+ .getCoercing()
+ .parseLiteral(new StringValue(input));
+ assertEquals(expected, odt);
+ }
+}
diff --git a/src/test/java/org/opentripplanner/apis/gtfs/mapping/RouteRequestMapperTest.java b/src/test/java/org/opentripplanner/apis/gtfs/mapping/RouteRequestMapperTest.java
index ecba3320838..22a8583d705 100644
--- a/src/test/java/org/opentripplanner/apis/gtfs/mapping/RouteRequestMapperTest.java
+++ b/src/test/java/org/opentripplanner/apis/gtfs/mapping/RouteRequestMapperTest.java
@@ -20,6 +20,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner._support.time.ZoneIds;
import org.opentripplanner.apis.gtfs.GraphQLRequestContext;
import org.opentripplanner.apis.gtfs.TestRoutingService;
@@ -34,7 +35,6 @@
import org.opentripplanner.service.realtimevehicles.internal.DefaultRealtimeVehicleService;
import org.opentripplanner.service.vehiclerental.internal.DefaultVehicleRentalService;
import org.opentripplanner.street.search.TraverseMode;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.service.DefaultTransitService;
import org.opentripplanner.transit.service.TransitModel;
@@ -91,25 +91,30 @@ void parkingFilters() {
testParkingFilters(routeRequest.preferences().parking(TraverseMode.BICYCLE));
}
- static Stream banningCases = Stream.of(
- of(Map.of(), "[TransitFilterRequest{}]"),
- of(
- Map.of("routes", "trimet:555"),
- "[TransitFilterRequest{not: [SelectRequest{transportModes: [], routes: [trimet:555]}]}]"
- ),
- of(Map.of("agencies", ""), "[TransitFilterRequest{not: [SelectRequest{transportModes: []}]}]"),
- of(
- Map.of("agencies", "trimet:666"),
- "[TransitFilterRequest{not: [SelectRequest{transportModes: [], agencies: [trimet:666]}]}]"
- ),
- of(
- Map.of("agencies", "trimet:666", "routes", "trimet:444"),
- "[TransitFilterRequest{not: [SelectRequest{transportModes: [], routes: [trimet:444]}, SelectRequest{transportModes: [], agencies: [trimet:666]}]}]"
- )
- );
+ static Stream banningCases() {
+ return Stream.of(
+ of(Map.of(), "[TransitFilterRequest{}]"),
+ of(
+ Map.of("routes", "trimet:555"),
+ "[TransitFilterRequest{not: [SelectRequest{transportModes: [], routes: [trimet:555]}]}]"
+ ),
+ of(
+ Map.of("agencies", ""),
+ "[TransitFilterRequest{not: [SelectRequest{transportModes: []}]}]"
+ ),
+ of(
+ Map.of("agencies", "trimet:666"),
+ "[TransitFilterRequest{not: [SelectRequest{transportModes: [], agencies: [trimet:666]}]}]"
+ ),
+ of(
+ Map.of("agencies", "trimet:666", "routes", "trimet:444"),
+ "[TransitFilterRequest{not: [SelectRequest{transportModes: [], routes: [trimet:444]}, SelectRequest{transportModes: [], agencies: [trimet:666]}]}]"
+ )
+ );
+ }
@ParameterizedTest
- @VariableSource("banningCases")
+ @MethodSource("banningCases")
void banning(Map banned, String expectedFilters) {
Map arguments = Map.of("banned", banned);
@@ -119,21 +124,23 @@ void banning(Map banned, String expectedFilters) {
assertEquals(expectedFilters, routeRequest.journey().transit().filters().toString());
}
- static Stream transportModesCases = Stream.of(
- of(List.of(), "[ExcludeAllTransitFilter{}]"),
- of(List.of(mode("BICYCLE")), "[ExcludeAllTransitFilter{}]"),
- of(
- List.of(mode("BUS")),
- "[TransitFilterRequest{select: [SelectRequest{transportModes: [BUS, COACH]}]}]"
- ),
- of(
- List.of(mode("BUS"), mode("MONORAIL")),
- "[TransitFilterRequest{select: [SelectRequest{transportModes: [BUS, COACH, MONORAIL]}]}]"
- )
- );
+ static Stream transportModesCases() {
+ return Stream.of(
+ of(List.of(), "[ExcludeAllTransitFilter{}]"),
+ of(List.of(mode("BICYCLE")), "[ExcludeAllTransitFilter{}]"),
+ of(
+ List.of(mode("BUS")),
+ "[TransitFilterRequest{select: [SelectRequest{transportModes: [BUS, COACH]}]}]"
+ ),
+ of(
+ List.of(mode("BUS"), mode("MONORAIL")),
+ "[TransitFilterRequest{select: [SelectRequest{transportModes: [BUS, COACH, MONORAIL]}]}]"
+ )
+ );
+ }
@ParameterizedTest
- @VariableSource("transportModesCases")
+ @MethodSource("transportModesCases")
void modes(List> modes, String expectedFilters) {
Map arguments = Map.of("transportModes", modes);
@@ -172,13 +179,15 @@ void bikeTriangle() {
);
}
- static Stream noTriangleCases = Arrays
- .stream(GraphQLTypes.GraphQLOptimizeType.values())
- .filter(value -> value != GraphQLTypes.GraphQLOptimizeType.TRIANGLE)
- .map(Arguments::of);
+ static Stream noTriangleCases() {
+ return Arrays
+ .stream(GraphQLTypes.GraphQLOptimizeType.values())
+ .filter(value -> value != GraphQLTypes.GraphQLOptimizeType.TRIANGLE)
+ .map(Arguments::of);
+ }
@ParameterizedTest
- @VariableSource("noTriangleCases")
+ @MethodSource("noTriangleCases")
void noTriangle(GraphQLTypes.GraphQLOptimizeType bot) {
Map arguments = Map.of(
"optimize",
diff --git a/src/test/java/org/opentripplanner/apis/transmodel/mapping/TripRequestMapperTest.java b/src/test/java/org/opentripplanner/apis/transmodel/mapping/TripRequestMapperTest.java
index c0bd96b6310..e35f198d16e 100644
--- a/src/test/java/org/opentripplanner/apis/transmodel/mapping/TripRequestMapperTest.java
+++ b/src/test/java/org/opentripplanner/apis/transmodel/mapping/TripRequestMapperTest.java
@@ -23,6 +23,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner._support.time.ZoneIds;
import org.opentripplanner.apis.transmodel.TransmodelRequestContext;
import org.opentripplanner.ext.emissions.DefaultEmissionsService;
@@ -50,7 +51,6 @@
import org.opentripplanner.standalone.server.DefaultServerRequestContext;
import org.opentripplanner.street.model.StreetLimitationParameters;
import org.opentripplanner.street.service.DefaultStreetLimitationParametersService;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.framework.Deduplicator;
import org.opentripplanner.transit.model.network.Route;
@@ -279,13 +279,12 @@ void testDefaultTriangleFactors() {
assertEquals(TimeSlopeSafetyTriangle.DEFAULT, req2.preferences().bike().optimizeTriangle());
}
- static Stream noTriangleCases = VehicleRoutingOptimizeType
- .nonTriangleValues()
- .stream()
- .map(Arguments::of);
+ static Stream noTriangleCases() {
+ return VehicleRoutingOptimizeType.nonTriangleValues().stream().map(Arguments::of);
+ }
@ParameterizedTest
- @VariableSource("noTriangleCases")
+ @MethodSource("noTriangleCases")
public void testBikeTriangleFactorsHasNoEffect(VehicleRoutingOptimizeType bot) {
Map arguments = Map.of(
"bicycleOptimisationMethod",
diff --git a/src/test/java/org/opentripplanner/apis/transmodel/model/scalars/DateTimeScalarFactoryTest.java b/src/test/java/org/opentripplanner/apis/transmodel/model/scalars/DateTimeScalarFactoryTest.java
index 43b44cbd5a6..c46c232751f 100644
--- a/src/test/java/org/opentripplanner/apis/transmodel/model/scalars/DateTimeScalarFactoryTest.java
+++ b/src/test/java/org/opentripplanner/apis/transmodel/model/scalars/DateTimeScalarFactoryTest.java
@@ -13,7 +13,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
class DateTimeScalarFactoryTest {
@@ -32,17 +32,19 @@ void serialize() {
assertEquals(DATE_TIME, result);
}
- static Stream testCases = Stream.of(
- Arguments.of(DATE_TIME),
- Arguments.of("2023-01-27T12:59:00.000+01:00"),
- Arguments.of("2023-01-27T12:59:00+0100"),
- Arguments.of("2023-01-27T12:59:00+01"),
- Arguments.of("2023-01-27T12:59:00"),
- Arguments.of("2023-01-27T11:59:00Z")
- );
+ static Stream testCases() {
+ return Stream.of(
+ Arguments.of(DATE_TIME),
+ Arguments.of("2023-01-27T12:59:00.000+01:00"),
+ Arguments.of("2023-01-27T12:59:00+0100"),
+ Arguments.of("2023-01-27T12:59:00+01"),
+ Arguments.of("2023-01-27T12:59:00"),
+ Arguments.of("2023-01-27T11:59:00Z")
+ );
+ }
@ParameterizedTest
- @VariableSource("testCases")
+ @MethodSource("testCases")
void parse(String input) {
var result = subject.getCoercing().parseValue(input);
assertEquals(EPOCH_MILLIS, result);
diff --git a/src/test/java/org/opentripplanner/framework/lang/StringUtilsTest.java b/src/test/java/org/opentripplanner/framework/lang/StringUtilsTest.java
index 8998d82a5f2..0e67344b2bb 100644
--- a/src/test/java/org/opentripplanner/framework/lang/StringUtilsTest.java
+++ b/src/test/java/org/opentripplanner/framework/lang/StringUtilsTest.java
@@ -3,6 +3,7 @@
import static java.lang.Boolean.FALSE;
import static java.lang.Boolean.TRUE;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -10,20 +11,23 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
class StringUtilsTest {
- static final Stream hasValueTestCases = Stream.of(
- Arguments.of("Text", TRUE),
- Arguments.of("T", TRUE),
- Arguments.of(null, FALSE),
- Arguments.of("", FALSE),
- Arguments.of("\t\n", FALSE)
- );
+ static Stream hasValueTestCases() {
+ return Stream.of(
+ Arguments.of("Text", TRUE),
+ Arguments.of("T", TRUE),
+ Arguments.of(null, FALSE),
+ Arguments.of("", FALSE),
+ Arguments.of("\t\n", FALSE)
+ );
+ }
@ParameterizedTest
- @VariableSource("hasValueTestCases")
+ @MethodSource("hasValueTestCases")
void hasValue(String input, Boolean hasValue) {
assertEquals(hasValue, StringUtils.hasValue(input));
assertEquals(!hasValue, StringUtils.hasNoValue(input));
@@ -82,4 +86,18 @@ void padRight() {
void quoteReplace() {
assertEquals("\"key\" : \"value\"", StringUtils.quoteReplace("'key' : 'value'"));
}
+
+ @ParameterizedTest
+ @ValueSource(
+ strings = { "\u200B", "\n", "\t", "\thello", "f\noo", "\ntri\nmet:123\t", "tri\u200Bmet:123" }
+ )
+ void containsInvisibleChars(String input) {
+ assertTrue(StringUtils.containsInvisibleCharacters(input));
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = { "", " ", "hello", " hello", " fo o " })
+ void noInvisibleChars(String input) {
+ assertFalse(StringUtils.containsInvisibleCharacters(input));
+ }
}
diff --git a/src/test/java/org/opentripplanner/framework/time/DurationUtilsTest.java b/src/test/java/org/opentripplanner/framework/time/DurationUtilsTest.java
index 86953760485..2457aa14b60 100644
--- a/src/test/java/org/opentripplanner/framework/time/DurationUtilsTest.java
+++ b/src/test/java/org/opentripplanner/framework/time/DurationUtilsTest.java
@@ -2,6 +2,7 @@
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.params.provider.Arguments.of;
import static org.opentripplanner.framework.time.DurationUtils.requireNonNegative;
import static org.opentripplanner.framework.time.DurationUtils.toIntMilliseconds;
@@ -13,6 +14,9 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.ResourceLock;
import org.junit.jupiter.api.parallel.Resources;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
public class DurationUtilsTest {
@@ -151,6 +155,29 @@ public void msToSecondsStr() {
}
}
+ static List durationCases() {
+ return List.of(
+ of(Duration.ofSeconds(30), "PT30S"),
+ of(Duration.ofMinutes(30), "PT30M"),
+ of(Duration.ofHours(23), "PT23H"),
+ of(Duration.ofSeconds(-30), "-PT30S"),
+ of(Duration.ofMinutes(-10), "-PT10M"),
+ of(Duration.ofMinutes(-90), "-PT1H30M"),
+ of(Duration.ofMinutes(-184), "-PT3H4M")
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("durationCases")
+ void formatDuration(Duration duration, String expected) {
+ var string = DurationUtils.formatDurationWithLeadingMinus(duration);
+
+ assertEquals(expected, string);
+
+ var parsed = Duration.parse(expected);
+ assertEquals(parsed, duration);
+ }
+
private static int durationSec(int hour, int min, int sec) {
return 60 * (60 * hour + min) + sec;
}
diff --git a/src/test/java/org/opentripplanner/framework/time/OffsetDateTimeParserTest.java b/src/test/java/org/opentripplanner/framework/time/OffsetDateTimeParserTest.java
new file mode 100644
index 00000000000..d8944b9a5f0
--- /dev/null
+++ b/src/test/java/org/opentripplanner/framework/time/OffsetDateTimeParserTest.java
@@ -0,0 +1,51 @@
+package org.opentripplanner.framework.time;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.text.ParseException;
+import java.time.OffsetDateTime;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class OffsetDateTimeParserTest {
+
+ private static final String TIME_STRING = "2023-01-27T12:59:00+01:00";
+ private static final OffsetDateTime TIME = OffsetDateTime.parse(TIME_STRING);
+
+ static List successfulCases() {
+ return List.of(
+ TIME_STRING,
+ "2023-01-27T12:59:00.000+01:00",
+ "2023-01-27T12:59:00+0100",
+ "2023-01-27T12:59:00+01",
+ "2023-01-27T11:59:00Z",
+ "2023-01-27T11:59Z",
+ "2023-01-27T06:59:00-05:00",
+ "2023-01-27T06:59:00-0500"
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("successfulCases")
+ void parse(String input) throws ParseException {
+ var res = OffsetDateTimeParser.parseLeniently(input);
+ assertTrue(res.isEqual(TIME));
+ }
+
+ static List failedCases() {
+ return List.of("2023-01-27T11:59:00", "2023-01-27T11", "2023-01-27T11:00");
+ }
+
+ @ParameterizedTest
+ @MethodSource("failedCases")
+ void failed(String input) {
+ Assertions.assertThrows(
+ ParseException.class,
+ () -> {
+ OffsetDateTimeParser.parseLeniently(input);
+ }
+ );
+ }
+}
diff --git a/src/test/java/org/opentripplanner/graph_builder/module/GtfsFeedIdTest.java b/src/test/java/org/opentripplanner/graph_builder/module/GtfsFeedIdTest.java
index 71a1d382983..133ec71070a 100644
--- a/src/test/java/org/opentripplanner/graph_builder/module/GtfsFeedIdTest.java
+++ b/src/test/java/org/opentripplanner/graph_builder/module/GtfsFeedIdTest.java
@@ -9,16 +9,18 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
class GtfsFeedIdTest {
private static final String NUMBERS_ONLY_REGEX = "^\\d+$";
- static Stream emptyCases = Stream.of(null, "", " ", "\n", " ").map(Arguments::of);
+ static Stream emptyCases() {
+ return Stream.of(null, "", " ", "\n", " ").map(Arguments::of);
+ }
@ParameterizedTest
- @VariableSource("emptyCases")
+ @MethodSource("emptyCases")
void autogenerateNumber(String id) {
String feedId = feedId(id);
assertTrue(feedId.matches(NUMBERS_ONLY_REGEX), "'%s' is not an integer.".formatted(feedId));
diff --git a/src/test/java/org/opentripplanner/graph_builder/module/GtfsModuleTest.java b/src/test/java/org/opentripplanner/graph_builder/module/GtfsModuleTest.java
index c628a14ad43..8123661990e 100644
--- a/src/test/java/org/opentripplanner/graph_builder/module/GtfsModuleTest.java
+++ b/src/test/java/org/opentripplanner/graph_builder/module/GtfsModuleTest.java
@@ -2,6 +2,7 @@
import static graphql.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.List;
import java.util.stream.Collectors;
@@ -23,7 +24,7 @@
class GtfsModuleTest {
@Test
- public void addShapesForFrequencyTrips() {
+ void addShapesForFrequencyTrips() {
var model = buildTestModel();
var bundle = new GtfsBundle(ConstantsForTests.SIMPLE_GTFS);
@@ -44,7 +45,7 @@ public void addShapesForFrequencyTrips() {
assertEquals(1, frequencyTripPattern.size());
- var tripPattern = frequencyTripPattern.get(0);
+ var tripPattern = frequencyTripPattern.getFirst();
assertNotNull(tripPattern.getGeometry());
assertNotNull(tripPattern.getHopGeometry(0));
@@ -53,6 +54,20 @@ public void addShapesForFrequencyTrips() {
assertNotNull(pattern.getHopGeometry(0));
}
+ @Test
+ void duplicateFeedId() {
+ var bundles = List.of(bundle("A"), bundle("A"));
+ var model = buildTestModel();
+
+ var module = new GtfsModule(
+ bundles,
+ model.transitModel,
+ model.graph,
+ ServiceDateInterval.unbounded()
+ );
+ assertThrows(IllegalArgumentException.class, module::buildGraph);
+ }
+
private static TestModels buildTestModel() {
var deduplicator = new Deduplicator();
var stopModel = new StopModel();
@@ -63,15 +78,15 @@ private static TestModels buildTestModel() {
record TestModels(Graph graph, TransitModel transitModel) {}
+ static GtfsBundle bundle(String feedId) {
+ var b = new GtfsBundle(ResourceLoader.of(GtfsModuleTest.class).file("/gtfs/interlining"));
+ b.setFeedId(new GtfsFeedId.Builder().id(feedId).build());
+ return b;
+ }
+
@Nested
class Interlining {
- static GtfsBundle bundle(String feedId) {
- var b = new GtfsBundle(ResourceLoader.of(GtfsModuleTest.class).file("/gtfs/interlining"));
- b.setFeedId(new GtfsFeedId.Builder().id(feedId).build());
- return b;
- }
-
static List interliningCases() {
return List.of(
Arguments.of(List.of(bundle("A")), 2),
@@ -86,7 +101,7 @@ static List interliningCases() {
*/
@ParameterizedTest(name = "Bundles {0} should generate {1} stay-seated transfers")
@MethodSource("interliningCases")
- public void interline(List bundles, int expectedTransfers) {
+ void interline(List bundles, int expectedTransfers) {
var model = buildTestModel();
var feedIds = bundles.stream().map(GtfsBundle::getFeedId).collect(Collectors.toSet());
diff --git a/src/test/java/org/opentripplanner/graph_builder/module/OsmBoardingLocationsModuleTest.java b/src/test/java/org/opentripplanner/graph_builder/module/OsmBoardingLocationsModuleTest.java
index 41c77f5df6e..1d8d819b5cb 100644
--- a/src/test/java/org/opentripplanner/graph_builder/module/OsmBoardingLocationsModuleTest.java
+++ b/src/test/java/org/opentripplanner/graph_builder/module/OsmBoardingLocationsModuleTest.java
@@ -9,6 +9,7 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.i18n.NonLocalizedString;
import org.opentripplanner.graph_builder.module.osm.OsmModule;
import org.opentripplanner.openstreetmap.OsmProvider;
@@ -23,7 +24,6 @@
import org.opentripplanner.street.model.vertex.VertexFactory;
import org.opentripplanner.street.model.vertex.VertexLabel;
import org.opentripplanner.test.support.ResourceLoader;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.basic.TransitMode;
import org.opentripplanner.transit.model.framework.Deduplicator;
@@ -49,21 +49,23 @@ class OsmBoardingLocationsModuleTest {
RegularStop busStop = testModel.stop("de:08115:4512:5:C", 48.59434, 8.86452).build();
RegularStop floatingBusStop = testModel.stop("floating-bus-stop", 48.59417, 8.86464).build();
- static Stream testCases = Stream.of(
- Arguments.of(
- false,
- Stream
- .of(302563833L, 3223067049L, 302563836L, 3223067680L, 302563834L, 768590748L, 302563839L)
- .map(VertexLabel::osm)
- .collect(Collectors.toSet())
- ),
- Arguments.of(true, Set.of(VertexLabel.osm(3223067049L), VertexLabel.osm(768590748)))
- );
+ static Stream testCases() {
+ return Stream.of(
+ Arguments.of(
+ false,
+ Stream
+ .of(302563833L, 3223067049L, 302563836L, 3223067680L, 302563834L, 768590748L, 302563839L)
+ .map(VertexLabel::osm)
+ .collect(Collectors.toSet())
+ ),
+ Arguments.of(true, Set.of(VertexLabel.osm(3223067049L), VertexLabel.osm(768590748)))
+ );
+ }
@ParameterizedTest(
name = "add boarding locations and link them to platform edges when skipVisibility={0}"
)
- @VariableSource("testCases")
+ @MethodSource("testCases")
void addAndLinkBoardingLocations(boolean areaVisibility, Set linkedVertices) {
var deduplicator = new Deduplicator();
var graph = new Graph(deduplicator);
diff --git a/src/test/java/org/opentripplanner/gtfs/interlining/InterlineProcessorTest.java b/src/test/java/org/opentripplanner/gtfs/interlining/InterlineProcessorTest.java
index 1e931589204..67ca61f0403 100644
--- a/src/test/java/org/opentripplanner/gtfs/interlining/InterlineProcessorTest.java
+++ b/src/test/java/org/opentripplanner/gtfs/interlining/InterlineProcessorTest.java
@@ -10,12 +10,12 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore;
import org.opentripplanner.gtfs.mapping.StaySeatedNotAllowed;
import org.opentripplanner.model.calendar.CalendarServiceData;
import org.opentripplanner.model.plan.PlanTestConstants;
import org.opentripplanner.model.transfer.DefaultTransferService;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.framework.Deduplicator;
import org.opentripplanner.transit.model.framework.FeedScopedId;
@@ -35,63 +35,65 @@ class InterlineProcessorTest implements PlanTestConstants {
tripPattern("trip-5", "block-2", "service-4")
);
- static Stream interlineTestCases = Stream.of(
- Arguments.of(
- List.of(
- new FeedScopedId("1", "service-1"),
- new FeedScopedId("1", "service-2"),
- new FeedScopedId("1", "service-3"),
- new FeedScopedId("1", "service-4")
+ static Stream interlineTestCases() {
+ return Stream.of(
+ Arguments.of(
+ List.of(
+ new FeedScopedId("1", "service-1"),
+ new FeedScopedId("1", "service-2"),
+ new FeedScopedId("1", "service-3"),
+ new FeedScopedId("1", "service-4")
+ ),
+ List.of(
+ List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1))
+ ),
+ "[ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-3, stopPos 0}, " +
+ "constraint: {staySeated}}, ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, " +
+ "to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}, " +
+ "ConstrainedTransfer{from: TripTP{F:trip-3, stopPos 2}, to: TripTP{F:trip-4, stopPos 0}, constraint: {staySeated}}]"
),
- List.of(
- List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1))
+ Arguments.of(
+ List.of(
+ new FeedScopedId("1", "service-1"),
+ new FeedScopedId("1", "service-2"),
+ new FeedScopedId("1", "service-3"),
+ new FeedScopedId("1", "service-4")
+ ),
+ List.of(
+ List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 5)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1))
+ ),
+ "[ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-3, stopPos 0}, " +
+ "constraint: {staySeated}}, ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, " +
+ "to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}, " +
+ "ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-4, stopPos 0}, constraint: {staySeated}}]"
),
- "[ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-3, stopPos 0}, " +
- "constraint: {staySeated}}, ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, " +
- "to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}, " +
- "ConstrainedTransfer{from: TripTP{F:trip-3, stopPos 2}, to: TripTP{F:trip-4, stopPos 0}, constraint: {staySeated}}]"
- ),
- Arguments.of(
- List.of(
- new FeedScopedId("1", "service-1"),
- new FeedScopedId("1", "service-2"),
- new FeedScopedId("1", "service-3"),
- new FeedScopedId("1", "service-4")
- ),
- List.of(
- List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1)),
- List.of(LocalDate.of(2023, Month.JANUARY, 5)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1))
- ),
- "[ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-3, stopPos 0}, " +
- "constraint: {staySeated}}, ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, " +
- "to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}, " +
- "ConstrainedTransfer{from: TripTP{F:trip-2, stopPos 2}, to: TripTP{F:trip-4, stopPos 0}, constraint: {staySeated}}]"
- ),
- // No common days between services
- Arguments.of(
- List.of(
- new FeedScopedId("1", "service-1"),
- new FeedScopedId("1", "service-2"),
- new FeedScopedId("1", "service-3"),
- new FeedScopedId("1", "service-4")
- ),
- List.of(
- List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
- List.of(LocalDate.of(2023, Month.JANUARY, 2)),
- List.of(LocalDate.of(2023, Month.JANUARY, 3)),
- List.of(LocalDate.of(2023, Month.JANUARY, 1))
- ),
- "[ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}]"
- )
- );
+ // No common days between services
+ Arguments.of(
+ List.of(
+ new FeedScopedId("1", "service-1"),
+ new FeedScopedId("1", "service-2"),
+ new FeedScopedId("1", "service-3"),
+ new FeedScopedId("1", "service-4")
+ ),
+ List.of(
+ List.of(LocalDate.of(2023, Month.JANUARY, 1), LocalDate.of(2023, Month.JANUARY, 5)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 2)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 3)),
+ List.of(LocalDate.of(2023, Month.JANUARY, 1))
+ ),
+ "[ConstrainedTransfer{from: TripTP{F:trip-1, stopPos 2}, to: TripTP{F:trip-2, stopPos 0}, constraint: {staySeated}}]"
+ )
+ );
+ }
@ParameterizedTest(name = "{0} services with {1} dates should generate transfers: {2}")
- @VariableSource("interlineTestCases")
+ @MethodSource("interlineTestCases")
void testInterline(
List serviceIds,
List> serviceDates,
diff --git a/src/test/java/org/opentripplanner/gtfs/mapping/LocationMapperTest.java b/src/test/java/org/opentripplanner/gtfs/mapping/LocationMapperTest.java
index e7a291fa976..4461c5a31f1 100644
--- a/src/test/java/org/opentripplanner/gtfs/mapping/LocationMapperTest.java
+++ b/src/test/java/org/opentripplanner/gtfs/mapping/LocationMapperTest.java
@@ -8,20 +8,19 @@
import org.geojson.Polygon;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.onebusaway.gtfs.model.AgencyAndId;
import org.onebusaway.gtfs.model.Location;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.service.StopModel;
class LocationMapperTest {
- static Stream testCases = Stream.of(
- Arguments.of(null, true),
- Arguments.of("a name", false)
- );
+ static Stream testCases() {
+ return Stream.of(Arguments.of(null, true), Arguments.of("a name", false));
+ }
@ParameterizedTest(name = "a name of <{0}> should set bogusName={1}")
- @VariableSource("testCases")
+ @MethodSource("testCases")
void testMapping(String name, boolean isBogusName) {
var gtfsLocation = new Location();
gtfsLocation.setId(new AgencyAndId("1", "zone-3"));
diff --git a/src/test/java/org/opentripplanner/gtfs/mapping/TransitModeMapperTest.java b/src/test/java/org/opentripplanner/gtfs/mapping/TransitModeMapperTest.java
index 39973a769c0..b2e5b1a8a4d 100644
--- a/src/test/java/org/opentripplanner/gtfs/mapping/TransitModeMapperTest.java
+++ b/src/test/java/org/opentripplanner/gtfs/mapping/TransitModeMapperTest.java
@@ -7,23 +7,25 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.transit.model.basic.TransitMode;
class TransitModeMapperTest {
- static Stream testCases = Stream.of(
- Arguments.of(1500, TAXI),
- Arguments.of(1510, TAXI),
- Arguments.of(1551, CARPOOL),
- Arguments.of(1555, CARPOOL),
- Arguments.of(1560, CARPOOL),
- Arguments.of(1561, TAXI),
- Arguments.of(1580, TAXI)
- );
+ static Stream testCases() {
+ return Stream.of(
+ Arguments.of(1500, TAXI),
+ Arguments.of(1510, TAXI),
+ Arguments.of(1551, CARPOOL),
+ Arguments.of(1555, CARPOOL),
+ Arguments.of(1560, CARPOOL),
+ Arguments.of(1561, TAXI),
+ Arguments.of(1580, TAXI)
+ );
+ }
@ParameterizedTest(name = "{0} should map to {1}")
- @VariableSource("testCases")
+ @MethodSource("testCases")
void map(int mode, TransitMode expectedMode) {
assertEquals(expectedMode, TransitModeMapper.mapMode(mode));
}
diff --git a/src/test/java/org/opentripplanner/model/plan/PlaceTest.java b/src/test/java/org/opentripplanner/model/plan/PlaceTest.java
index 573e4597e39..95d7cf629a2 100644
--- a/src/test/java/org/opentripplanner/model/plan/PlaceTest.java
+++ b/src/test/java/org/opentripplanner/model/plan/PlaceTest.java
@@ -9,13 +9,13 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.opentripplanner.framework.geometry.GeometryUtils;
import org.opentripplanner.framework.i18n.I18NString;
import org.opentripplanner.framework.i18n.NonLocalizedString;
import org.opentripplanner.street.model.vertex.SimpleVertex;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.framework.FeedScopedId;
import org.opentripplanner.transit.model.site.RegularStop;
@@ -65,17 +65,19 @@ public void sameLocationBasedOnStopId() {
assertFalse(otherPlace.sameLocation(aPlace), "other place(symmetric)");
}
- static Stream flexStopCases = Stream.of(
- Arguments.of(null, "an intersection name"),
- Arguments.of(new NonLocalizedString("1:stop_id"), "an intersection name (part of 1:stop_id)"),
- Arguments.of(
- new NonLocalizedString("Flex Zone 123"),
- "an intersection name (part of Flex Zone 123)"
- )
- );
+ static Stream flexStopCases() {
+ return Stream.of(
+ Arguments.of(null, "an intersection name"),
+ Arguments.of(new NonLocalizedString("1:stop_id"), "an intersection name (part of 1:stop_id)"),
+ Arguments.of(
+ new NonLocalizedString("Flex Zone 123"),
+ "an intersection name (part of Flex Zone 123)"
+ )
+ );
+ }
@ParameterizedTest(name = "Flex stop name of {0} should lead to a place name of {1}")
- @VariableSource("flexStopCases")
+ @MethodSource("flexStopCases")
public void flexStop(I18NString stopName, String expectedPlaceName) {
var stop = StopModel
.of()
diff --git a/src/test/java/org/opentripplanner/model/plan/RelativeDirectionTest.java b/src/test/java/org/opentripplanner/model/plan/RelativeDirectionTest.java
index c60861d28f8..c3cb4e0a78c 100644
--- a/src/test/java/org/opentripplanner/model/plan/RelativeDirectionTest.java
+++ b/src/test/java/org/opentripplanner/model/plan/RelativeDirectionTest.java
@@ -15,37 +15,39 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
class RelativeDirectionTest {
@SuppressWarnings("unused")
- static Stream testCasesNormal = Stream.of(
- // Turn Right
- tc(0, CONTINUE),
- tc(17, CONTINUE),
- tc(18, SLIGHTLY_RIGHT),
- tc(40, SLIGHTLY_RIGHT),
- tc(41, RIGHT),
- tc(114, RIGHT),
- tc(115, HARD_RIGHT),
- tc(179, HARD_RIGHT),
- tc(180, HARD_LEFT),
- // Turn Left
- tc(0, CONTINUE),
- tc(-17, CONTINUE),
- tc(-18, SLIGHTLY_LEFT),
- tc(-40, SLIGHTLY_LEFT),
- tc(-41, LEFT),
- tc(-114, LEFT),
- tc(-115, HARD_LEFT),
- tc(-179, HARD_LEFT),
- tc(-180, HARD_LEFT),
- tc(-181, HARD_RIGHT)
- );
+ static Stream testCasesNormal() {
+ return Stream.of(
+ // Turn Right
+ tc(0, CONTINUE),
+ tc(17, CONTINUE),
+ tc(18, SLIGHTLY_RIGHT),
+ tc(40, SLIGHTLY_RIGHT),
+ tc(41, RIGHT),
+ tc(114, RIGHT),
+ tc(115, HARD_RIGHT),
+ tc(179, HARD_RIGHT),
+ tc(180, HARD_LEFT),
+ // Turn Left
+ tc(0, CONTINUE),
+ tc(-17, CONTINUE),
+ tc(-18, SLIGHTLY_LEFT),
+ tc(-40, SLIGHTLY_LEFT),
+ tc(-41, LEFT),
+ tc(-114, LEFT),
+ tc(-115, HARD_LEFT),
+ tc(-179, HARD_LEFT),
+ tc(-180, HARD_LEFT),
+ tc(-181, HARD_RIGHT)
+ );
+ }
@ParameterizedTest(name = "Turning {0} degrees should give a relative direction of {1}")
- @VariableSource("testCasesNormal")
+ @MethodSource("testCasesNormal")
void testCalculateForNormalIntersections(int thisAngleDegrees, RelativeDirection expected) {
assertEquals(expected, RelativeDirection.calculate(angle(thisAngleDegrees), false));
}
diff --git a/src/test/java/org/opentripplanner/model/plan/ScheduledTransitLegTest.java b/src/test/java/org/opentripplanner/model/plan/ScheduledTransitLegTest.java
index e45beb8ebad..b41ace81e8d 100644
--- a/src/test/java/org/opentripplanner/model/plan/ScheduledTransitLegTest.java
+++ b/src/test/java/org/opentripplanner/model/plan/ScheduledTransitLegTest.java
@@ -1,6 +1,8 @@
package org.opentripplanner.model.plan;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.opentripplanner.transit.model._data.TransitModelForTest.id;
import java.time.OffsetDateTime;
@@ -9,33 +11,74 @@
import org.junit.jupiter.api.Test;
import org.opentripplanner._support.time.ZoneIds;
import org.opentripplanner.transit.model._data.TransitModelForTest;
+import org.opentripplanner.transit.model.network.Route;
+import org.opentripplanner.transit.model.network.TripPattern;
+import org.opentripplanner.transit.model.timetable.RealTimeTripTimes;
+import org.opentripplanner.transit.model.timetable.ScheduledTripTimes;
+import org.opentripplanner.transit.model.timetable.Trip;
class ScheduledTransitLegTest {
static final ZonedDateTime TIME = OffsetDateTime
.parse("2023-04-17T17:49:06+02:00")
.toZonedDateTime();
+ private static final TransitModelForTest TEST_MODEL = TransitModelForTest.of();
+ private static final Route ROUTE = TransitModelForTest.route(id("2")).build();
+ private static final TripPattern PATTERN = TransitModelForTest
+ .tripPattern("1", ROUTE)
+ .withStopPattern(TEST_MODEL.stopPattern(3))
+ .build();
+ private static final Trip TRIP = TransitModelForTest.trip("trip1").build();
+ private static final ScheduledTripTimes TRIP_TIMES = ScheduledTripTimes
+ .of()
+ .withArrivalTimes("10:00 11:00 12:00")
+ .withDepartureTimes("10:01 11:02 12:03")
+ .withTrip(TRIP)
+ .build();
@Test
void defaultFares() {
- var testModel = TransitModelForTest.of();
- var route = TransitModelForTest.route(id("2")).build();
- var pattern = TransitModelForTest
- .tripPattern("1", route)
- .withStopPattern(testModel.stopPattern(3))
+ var leg = builder().build();
+
+ assertEquals(List.of(), leg.fareProducts());
+ }
+
+ @Test
+ void legTimesWithoutRealTime() {
+ var leg = builder().withTripTimes(TRIP_TIMES).build();
+
+ assertNull(leg.start().estimated());
+ assertNull(leg.end().estimated());
+ }
+
+ @Test
+ void legTimesWithRealTime() {
+ var tt = ScheduledTripTimes
+ .of()
+ .withArrivalTimes("10:00 11:00 12:00")
+ .withDepartureTimes("10:01 11:02 12:03")
+ .withTrip(TRIP)
.build();
- var leg = new ScheduledTransitLegBuilder()
+
+ var rtt = RealTimeTripTimes.of(tt);
+ rtt.updateArrivalTime(0, 111);
+
+ var leg = builder().withTripTimes(rtt).build();
+
+ assertNotNull(leg.start().estimated());
+ assertNotNull(leg.end().estimated());
+ }
+
+ private static ScheduledTransitLegBuilder builder() {
+ return new ScheduledTransitLegBuilder()
.withTripTimes(null)
- .withTripPattern(pattern)
+ .withTripPattern(PATTERN)
.withBoardStopIndexInPattern(0)
.withAlightStopIndexInPattern(2)
.withStartTime(TIME)
.withEndTime(TIME.plusMinutes(10))
.withServiceDate(TIME.toLocalDate())
.withZoneId(ZoneIds.BERLIN)
- .withGeneralizedCost(100)
- .build();
-
- assertEquals(List.of(), leg.fareProducts());
+ .withGeneralizedCost(100);
}
}
diff --git a/src/test/java/org/opentripplanner/openstreetmap/OSMOpeningHoursParserTest.java b/src/test/java/org/opentripplanner/openstreetmap/OSMOpeningHoursParserTest.java
index f1068bb8220..34f141e8504 100644
--- a/src/test/java/org/opentripplanner/openstreetmap/OSMOpeningHoursParserTest.java
+++ b/src/test/java/org/opentripplanner/openstreetmap/OSMOpeningHoursParserTest.java
@@ -12,9 +12,9 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner._support.time.ZoneIds;
import org.opentripplanner.model.calendar.openinghours.OpeningHoursCalendarService;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model.framework.Deduplicator;
public class OSMOpeningHoursParserTest {
@@ -30,150 +30,152 @@ public class OSMOpeningHoursParserTest {
ZoneIds.PARIS
);
- static Stream osmOpeningHoursTestCases = Stream.of(
- Arguments.of(
- "Mo-Fr 14:00-19:00",
- List.of("2022-10-25T14:30:00Z"),
- List.of("2022-10-25T08:30:00Z", "2022-10-29T14:30:00Z")
- ),
- Arguments.of(
- "Tu 10:00-15:00",
- List.of("2022-10-25T10:30:00Z"),
- List.of("2022-10-26T00:30:00Z", "2022-10-27T10:30:00Z")
- ),
- Arguments.of(
- "Mo-Fr 08:00-17:00;Sa-Su 10:00-13:00",
- List.of("2022-10-25T07:30:00Z", "2022-10-29T10:30:00Z"),
- List.of("2022-10-25T03:30:00Z", "2022-10-29T15:30:00Z")
- ),
- // TODO implement support for public holidays, currently only the first two rules are handled
- Arguments.of(
- "Mo-Fr 08:00-17:00;Sa-Su 10:00-13:00; PH off",
- List.of("2022-10-25T07:30:00Z", "2022-10-29T10:30:00Z"),
- List.of("2022-10-25T03:30:00Z", "2022-10-29T15:30:00Z")
- ),
- // TODO implement support for public holidays, currently only the first two rules are handled
- Arguments.of(
- "Mo,We,Th,Fr,Su 00:00-24:00; Tu,Sa 00:00-02:00, 14:30-24:00; PH 00:00-24:00",
- List.of("2022-10-24T15:30:00Z", "2022-10-24T23:30:00Z", "2022-10-25T15:30:00Z"),
- List.of("2022-10-25T05:30:00Z")
- ),
- // The second rule overrides the first rule for Wednesdays, i.e. on Wednesdays it should only be
- // open from 10:00 to 13:00
- Arguments.of(
- "Mo-Fr 16:00-02:00; We 10:00-13:00",
- List.of("2022-10-25T23:30:00Z", "2022-10-26T10:30:00Z", "2022-10-27T23:30:00Z"),
- List.of("2022-10-25T10:30:00Z", "2022-10-26T23:30:00Z")
- ),
- // The second rule overrides the first rule for Tuesdays, i.e. it should be closed on Tuesdays
- Arguments.of(
- "Mo - Sa 10:00-18:00; Tu off",
- List.of("2022-10-24T15:30:00Z"),
- List.of("2022-10-24T05:30:00Z", "2022-10-25T10:30:00Z")
- ),
- // Even though the following rules are not additive, they should be handled as such because they
- // have the off modifier (https://github.com/opening-hours/opening_hours.js/issues/53).
- // Therefore, it should be open according to the first rule outside of the defined off periods,
- // so for example, on Tuesdays it should be open from 07:30 to 12:00 and from 16:00 to 22:00.
- // These different off cases are needed because they overlap slightly differently with the first
- // rule and have slightly different handling in code.
- Arguments.of(
- "Mo-Sa 07:30-22:00; Mo 05:00-23:00 off; Tu 12:00-16:00 off; We 06:00-16:00 off; Th 07:30-16:00 off, Fr 16:00-22:00 off, Sa 16:00-23:00 off",
- List.of(
- "2022-10-25T07:30:00Z",
- "2022-10-25T17:30:00Z",
- "2022-10-26T17:30:00Z",
- "2022-10-27T17:30:00Z",
- "2022-10-28T07:30:00Z",
- "2022-10-29T07:30:00Z"
- ),
- List.of(
- "2022-10-24T07:30:00Z",
- "2022-10-25T12:30:00Z",
- "2022-10-26T07:30:00Z",
- "2022-10-27T07:30:00Z",
- "2022-10-28T16:30:00Z",
- "2022-10-29T16:30:00Z",
- "2022-10-30T07:30:00Z"
+ static Stream osmOpeningHoursTestCases() {
+ return Stream.of(
+ Arguments.of(
+ "Mo-Fr 14:00-19:00",
+ List.of("2022-10-25T14:30:00Z"),
+ List.of("2022-10-25T08:30:00Z", "2022-10-29T14:30:00Z")
+ ),
+ Arguments.of(
+ "Tu 10:00-15:00",
+ List.of("2022-10-25T10:30:00Z"),
+ List.of("2022-10-26T00:30:00Z", "2022-10-27T10:30:00Z")
+ ),
+ Arguments.of(
+ "Mo-Fr 08:00-17:00;Sa-Su 10:00-13:00",
+ List.of("2022-10-25T07:30:00Z", "2022-10-29T10:30:00Z"),
+ List.of("2022-10-25T03:30:00Z", "2022-10-29T15:30:00Z")
+ ),
+ // TODO implement support for public holidays, currently only the first two rules are handled
+ Arguments.of(
+ "Mo-Fr 08:00-17:00;Sa-Su 10:00-13:00; PH off",
+ List.of("2022-10-25T07:30:00Z", "2022-10-29T10:30:00Z"),
+ List.of("2022-10-25T03:30:00Z", "2022-10-29T15:30:00Z")
+ ),
+ // TODO implement support for public holidays, currently only the first two rules are handled
+ Arguments.of(
+ "Mo,We,Th,Fr,Su 00:00-24:00; Tu,Sa 00:00-02:00, 14:30-24:00; PH 00:00-24:00",
+ List.of("2022-10-24T15:30:00Z", "2022-10-24T23:30:00Z", "2022-10-25T15:30:00Z"),
+ List.of("2022-10-25T05:30:00Z")
+ ),
+ // The second rule overrides the first rule for Wednesdays, i.e. on Wednesdays it should only be
+ // open from 10:00 to 13:00
+ Arguments.of(
+ "Mo-Fr 16:00-02:00; We 10:00-13:00",
+ List.of("2022-10-25T23:30:00Z", "2022-10-26T10:30:00Z", "2022-10-27T23:30:00Z"),
+ List.of("2022-10-25T10:30:00Z", "2022-10-26T23:30:00Z")
+ ),
+ // The second rule overrides the first rule for Tuesdays, i.e. it should be closed on Tuesdays
+ Arguments.of(
+ "Mo - Sa 10:00-18:00; Tu off",
+ List.of("2022-10-24T15:30:00Z"),
+ List.of("2022-10-24T05:30:00Z", "2022-10-25T10:30:00Z")
+ ),
+ // Even though the following rules are not additive, they should be handled as such because they
+ // have the off modifier (https://github.com/opening-hours/opening_hours.js/issues/53).
+ // Therefore, it should be open according to the first rule outside of the defined off periods,
+ // so for example, on Tuesdays it should be open from 07:30 to 12:00 and from 16:00 to 22:00.
+ // These different off cases are needed because they overlap slightly differently with the first
+ // rule and have slightly different handling in code.
+ Arguments.of(
+ "Mo-Sa 07:30-22:00; Mo 05:00-23:00 off; Tu 12:00-16:00 off; We 06:00-16:00 off; Th 07:30-16:00 off, Fr 16:00-22:00 off, Sa 16:00-23:00 off",
+ List.of(
+ "2022-10-25T07:30:00Z",
+ "2022-10-25T17:30:00Z",
+ "2022-10-26T17:30:00Z",
+ "2022-10-27T17:30:00Z",
+ "2022-10-28T07:30:00Z",
+ "2022-10-29T07:30:00Z"
+ ),
+ List.of(
+ "2022-10-24T07:30:00Z",
+ "2022-10-25T12:30:00Z",
+ "2022-10-26T07:30:00Z",
+ "2022-10-27T07:30:00Z",
+ "2022-10-28T16:30:00Z",
+ "2022-10-29T16:30:00Z",
+ "2022-10-30T07:30:00Z"
+ )
+ ),
+ // This tests that it's correctly closed outside with an off rule that extends over midnight
+ Arguments.of(
+ "Mo-Fr 12:30-04:00; We 18:00-02:00 off",
+ List.of(
+ "2022-10-25T19:30:00Z",
+ "2022-10-25T23:30:00Z",
+ "2022-10-26T13:30:00Z",
+ "2022-10-27T01:30:00Z",
+ "2022-10-27T23:30:00Z"
+ ),
+ List.of("2022-10-26T19:30:00Z", "2022-10-26T23:30:00Z", "2022-10-27T05:30:00Z")
+ ),
+ Arguments.of(
+ "open; Tu 13:00-16:00 off",
+ List.of("2022-10-24T12:30:00Z", "2022-10-25T07:30:00Z", "2022-10-24T18:30:00Z"),
+ List.of("2022-10-25T13:30:00Z")
+ ),
+ Arguments.of(
+ "Su-Tu 11:00-02:00, We-Th 11:00-03:00, Fr 11:00-06:00, Sa 11:00-07:00",
+ List.of("2022-10-25T14:30:00Z", "2022-10-25T23:30:00Z", "2022-10-29T03:30:00Z"),
+ List.of("2022-10-25T02:30:00Z", "2022-10-27T03:30:00Z")
+ ),
+ Arguments.of(
+ "Sep-Oct: Mo-Sa 10:00-02:00",
+ List.of("2022-09-30T23:30:00Z", "2022-10-29T10:30:00Z", "2022-10-31T23:30:00Z"),
+ List.of("2022-10-30T10:30:00Z", "2022-11-26T10:30:00Z")
+ ),
+ Arguments.of(
+ "Oct: Mo 10:00-02:00",
+ List.of("2022-10-24T10:30:00Z", "2022-10-31T23:30:00Z"),
+ List.of("2022-09-30T23:30:00Z", "2022-10-30T10:30:00Z", "2022-11-07T10:30:00Z")
+ ),
+ // TODO implement support for dates with and without year, this is now completely unparsed
+ // which means that it's never open
+ Arguments.of("Oct 23-Jan 3: 10:00-23:00", List.of(), List.of("2022-10-20T12:30:00Z")),
+ // TODO implement support for nth weekday in a month and offsets
+ Arguments.of(
+ "Mar Su[-1]-Oct Su[1] -2 days: 22:00-23:00",
+ List.of(),
+ List.of("2022-11-20T12:30:00Z")
+ ),
+ Arguments.of("24/7", List.of("2022-10-25T07:30:00Z"), List.of()),
+ Arguments.of("24/7 closed", List.of(), List.of("2022-10-25T07:30:00Z")),
+ // TODO implement support for school holidays and special dates, only the first rule is now
+ // handled
+ Arguments.of(
+ "Mo-Su,SH 15:00-03:00; easter -2 days off",
+ List.of("2022-10-25T15:30:00Z"),
+ List.of("2022-10-25T05:30:00Z")
+ ),
+ // TODO implement support for comment modifiers, this is now interpreted to be always closed
+ Arguments.of("\"by appointment\"", List.of(), List.of("2022-10-25T07:30:00Z")),
+ // TODO implement support for fallbacks if feasible, now the last rule is ignored and the first
+ // rule is respected
+ Arguments.of(
+ "Mo-Sa 08:00-13:00,16:00-18:00 || \"by appointment\"",
+ List.of("2022-10-25T07:30:00Z", "2022-10-25T15:30:00Z"),
+ List.of("2022-10-25T13:30:00Z", "2022-10-30T07:30:00Z")
+ ),
+ // TODO implement support for weeks, these rules are now ignored and it's always closed
+ Arguments.of(
+ "week 1-53/2 Fr 09:00-12:00; week 2-52/2 We 09:00-12:00",
+ List.of(),
+ List.of("2022-10-28T07:30:00Z")
+ ),
+ // TODO implement support for events, this is now interpreted to be always closed
+ Arguments.of("sunrise-sunset", List.of(), List.of("2022-10-25T07:30:00Z")),
+ // This is interpreted to be open on sundays from 10:00 until 23:59
+ Arguments.of(
+ "Su 10:00+",
+ List.of("2022-10-30T10:30:00Z"),
+ List.of("2022-10-25T10:30:00Z", "2022-10-30T06:30:00Z")
)
- ),
- // This tests that it's correctly closed outside with an off rule that extends over midnight
- Arguments.of(
- "Mo-Fr 12:30-04:00; We 18:00-02:00 off",
- List.of(
- "2022-10-25T19:30:00Z",
- "2022-10-25T23:30:00Z",
- "2022-10-26T13:30:00Z",
- "2022-10-27T01:30:00Z",
- "2022-10-27T23:30:00Z"
- ),
- List.of("2022-10-26T19:30:00Z", "2022-10-26T23:30:00Z", "2022-10-27T05:30:00Z")
- ),
- Arguments.of(
- "open; Tu 13:00-16:00 off",
- List.of("2022-10-24T12:30:00Z", "2022-10-25T07:30:00Z", "2022-10-24T18:30:00Z"),
- List.of("2022-10-25T13:30:00Z")
- ),
- Arguments.of(
- "Su-Tu 11:00-02:00, We-Th 11:00-03:00, Fr 11:00-06:00, Sa 11:00-07:00",
- List.of("2022-10-25T14:30:00Z", "2022-10-25T23:30:00Z", "2022-10-29T03:30:00Z"),
- List.of("2022-10-25T02:30:00Z", "2022-10-27T03:30:00Z")
- ),
- Arguments.of(
- "Sep-Oct: Mo-Sa 10:00-02:00",
- List.of("2022-09-30T23:30:00Z", "2022-10-29T10:30:00Z", "2022-10-31T23:30:00Z"),
- List.of("2022-10-30T10:30:00Z", "2022-11-26T10:30:00Z")
- ),
- Arguments.of(
- "Oct: Mo 10:00-02:00",
- List.of("2022-10-24T10:30:00Z", "2022-10-31T23:30:00Z"),
- List.of("2022-09-30T23:30:00Z", "2022-10-30T10:30:00Z", "2022-11-07T10:30:00Z")
- ),
- // TODO implement support for dates with and without year, this is now completely unparsed
- // which means that it's never open
- Arguments.of("Oct 23-Jan 3: 10:00-23:00", List.of(), List.of("2022-10-20T12:30:00Z")),
- // TODO implement support for nth weekday in a month and offsets
- Arguments.of(
- "Mar Su[-1]-Oct Su[1] -2 days: 22:00-23:00",
- List.of(),
- List.of("2022-11-20T12:30:00Z")
- ),
- Arguments.of("24/7", List.of("2022-10-25T07:30:00Z"), List.of()),
- Arguments.of("24/7 closed", List.of(), List.of("2022-10-25T07:30:00Z")),
- // TODO implement support for school holidays and special dates, only the first rule is now
- // handled
- Arguments.of(
- "Mo-Su,SH 15:00-03:00; easter -2 days off",
- List.of("2022-10-25T15:30:00Z"),
- List.of("2022-10-25T05:30:00Z")
- ),
- // TODO implement support for comment modifiers, this is now interpreted to be always closed
- Arguments.of("\"by appointment\"", List.of(), List.of("2022-10-25T07:30:00Z")),
- // TODO implement support for fallbacks if feasible, now the last rule is ignored and the first
- // rule is respected
- Arguments.of(
- "Mo-Sa 08:00-13:00,16:00-18:00 || \"by appointment\"",
- List.of("2022-10-25T07:30:00Z", "2022-10-25T15:30:00Z"),
- List.of("2022-10-25T13:30:00Z", "2022-10-30T07:30:00Z")
- ),
- // TODO implement support for weeks, these rules are now ignored and it's always closed
- Arguments.of(
- "week 1-53/2 Fr 09:00-12:00; week 2-52/2 We 09:00-12:00",
- List.of(),
- List.of("2022-10-28T07:30:00Z")
- ),
- // TODO implement support for events, this is now interpreted to be always closed
- Arguments.of("sunrise-sunset", List.of(), List.of("2022-10-25T07:30:00Z")),
- // This is interpreted to be open on sundays from 10:00 until 23:59
- Arguments.of(
- "Su 10:00+",
- List.of("2022-10-30T10:30:00Z"),
- List.of("2022-10-25T10:30:00Z", "2022-10-30T06:30:00Z")
- )
- );
+ );
+ }
@ParameterizedTest(name = "{0} should be open on {1} but not on {2}")
- @VariableSource("osmOpeningHoursTestCases")
+ @MethodSource("osmOpeningHoursTestCases")
void testOSMOpeningHoursParsing(
String openingHours,
List openTimes,
diff --git a/src/test/java/org/opentripplanner/openstreetmap/tagmapping/PortlandMapperTest.java b/src/test/java/org/opentripplanner/openstreetmap/tagmapping/PortlandMapperTest.java
index 06369baddc8..26f45fd8c32 100644
--- a/src/test/java/org/opentripplanner/openstreetmap/tagmapping/PortlandMapperTest.java
+++ b/src/test/java/org/opentripplanner/openstreetmap/tagmapping/PortlandMapperTest.java
@@ -18,30 +18,33 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.openstreetmap.model.OSMWithTags;
import org.opentripplanner.openstreetmap.wayproperty.WayPropertySet;
-import org.opentripplanner.test.support.VariableSource;
public class PortlandMapperTest {
static double delta = 0.1;
static WayPropertySet wps = new WayPropertySet();
- static Stream cases = Stream.of(
- Arguments.of(southeastLaBonitaWay(), 0.8),
- Arguments.of(southwestMayoStreet(), 0.9),
- Arguments.of(sidewalkBoth(), 0.96),
- Arguments.of(pedestrianTunnel(), 1.0),
- Arguments.of(highwayTertiaryWithSidewalk(), 1.056),
- Arguments.of(cobblestones(), 1.2),
- Arguments.of(noSidewalk(), 1.2),
- Arguments.of(carTunnel(), 1.2),
- Arguments.of(footwaySidewalk(), 1.32),
- Arguments.of(highwayTertiary(), 1.32),
- Arguments.of(highwayTrunk(), 1.44),
- Arguments.of(fiveLanes(), 1.584),
- Arguments.of(noSidewalkHighSpeed(), 7.19)
- );
+
+ static Stream cases() {
+ return Stream.of(
+ Arguments.of(southeastLaBonitaWay(), 0.8),
+ Arguments.of(southwestMayoStreet(), 0.9),
+ Arguments.of(sidewalkBoth(), 0.96),
+ Arguments.of(pedestrianTunnel(), 1.0),
+ Arguments.of(highwayTertiaryWithSidewalk(), 1.056),
+ Arguments.of(cobblestones(), 1.2),
+ Arguments.of(noSidewalk(), 1.2),
+ Arguments.of(carTunnel(), 1.2),
+ Arguments.of(footwaySidewalk(), 1.32),
+ Arguments.of(highwayTertiary(), 1.32),
+ Arguments.of(highwayTrunk(), 1.44),
+ Arguments.of(fiveLanes(), 1.584),
+ Arguments.of(noSidewalkHighSpeed(), 7.19)
+ );
+ }
static {
var source = new PortlandMapper();
@@ -49,7 +52,7 @@ public class PortlandMapperTest {
}
@ParameterizedTest(name = "way {0} should have walk safety factor {1}")
- @VariableSource("cases")
+ @MethodSource("cases")
void walkSafety(OSMWithTags way, double expected) {
var score = wps.getDataForWay(way);
diff --git a/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/BestMatchSpecifierTest.java b/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/BestMatchSpecifierTest.java
index 19575c9312f..517e4b57bfd 100644
--- a/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/BestMatchSpecifierTest.java
+++ b/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/BestMatchSpecifierTest.java
@@ -8,8 +8,8 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.openstreetmap.model.OSMWithTags;
-import org.opentripplanner.test.support.VariableSource;
class BestMatchSpecifierTest extends SpecifierTest {
@@ -48,17 +48,19 @@ void leftRightMatch() {
assertEquals(100, result.forward());
}
- static Stream leftRightTestCases = Stream.of(
- Arguments.of(cyclewayLeft(), bikeLane, 210, 100),
- Arguments.of(cyclewayLaneTrack(), cyclewayTrack, 100, 210),
- Arguments.of(cyclewayLaneTrack(), highwayFootwayCyclewayLane, 210, 100),
- Arguments.of(cyclewayLaneTrack(), cyclewayLane, 110, 0)
- );
+ static Stream leftRightTestCases() {
+ return Stream.of(
+ Arguments.of(cyclewayLeft(), bikeLane, 210, 100),
+ Arguments.of(cyclewayLaneTrack(), cyclewayTrack, 100, 210),
+ Arguments.of(cyclewayLaneTrack(), highwayFootwayCyclewayLane, 210, 100),
+ Arguments.of(cyclewayLaneTrack(), cyclewayLane, 110, 0)
+ );
+ }
@ParameterizedTest(
name = "way {0} with specifier {1} should have a backward score {2} and forward score {3}"
)
- @VariableSource("leftRightTestCases")
+ @MethodSource("leftRightTestCases")
void leftRight(OSMWithTags way, OsmSpecifier spec, int expectedBackward, int expectedForward) {
var result = spec.matchScores(way);
assertEquals(expectedBackward, result.backward());
diff --git a/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/ConditionTest.java b/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/ConditionTest.java
index a1d126003a5..def272652f6 100644
--- a/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/ConditionTest.java
+++ b/src/test/java/org/opentripplanner/openstreetmap/wayproperty/specifier/ConditionTest.java
@@ -25,6 +25,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.openstreetmap.model.OSMWithTags;
import org.opentripplanner.openstreetmap.wayproperty.specifier.Condition.Absent;
import org.opentripplanner.openstreetmap.wayproperty.specifier.Condition.Equals;
@@ -34,7 +35,6 @@
import org.opentripplanner.openstreetmap.wayproperty.specifier.Condition.LessThan;
import org.opentripplanner.openstreetmap.wayproperty.specifier.Condition.MatchResult;
import org.opentripplanner.openstreetmap.wayproperty.specifier.Condition.Present;
-import org.opentripplanner.test.support.VariableSource;
class ConditionTest {
@@ -56,18 +56,20 @@ class ConditionTest {
);
static Condition noSidewalk = new Condition.EqualsAnyInOrAbsent("sidewalk");
- static Stream equalsCases = Stream.of(
- Arguments.of(cyclewayLeft(), cyclewayLane, EXACT, NONE),
- Arguments.of(cyclewayLaneTrack(), cyclewayLane, EXACT, NONE),
- Arguments.of(cyclewayBoth(), cyclewayLane, EXACT, EXACT),
- Arguments.of(cyclewayLaneTrack(), cyclewayTrack, NONE, EXACT),
- Arguments.of(tramsForward(), embeddedTrams, NONE, EXACT)
- );
+ static Stream equalsCases() {
+ return Stream.of(
+ Arguments.of(cyclewayLeft(), cyclewayLane, EXACT, NONE),
+ Arguments.of(cyclewayLaneTrack(), cyclewayLane, EXACT, NONE),
+ Arguments.of(cyclewayBoth(), cyclewayLane, EXACT, EXACT),
+ Arguments.of(cyclewayLaneTrack(), cyclewayTrack, NONE, EXACT),
+ Arguments.of(tramsForward(), embeddedTrams, NONE, EXACT)
+ );
+ }
@ParameterizedTest(
name = "way {0} with op {1} should have a backward result {2}, forward result {3}"
)
- @VariableSource("equalsCases")
+ @MethodSource("equalsCases")
void leftRight(
OSMWithTags way,
Condition op,
@@ -78,32 +80,34 @@ void leftRight(
assertEquals(forwardExpectation, op.matchForward(way));
}
- static Stream otherCases = Stream.of(
- Arguments.of(cycleway(), cyclewayPresent, WILDCARD),
- Arguments.of(carTunnel(), cyclewayPresent, NONE),
- Arguments.of(carTunnel(), cyclewayAbsent, EXACT),
- Arguments.of(cobblestones(), cyclewayAbsent, EXACT),
- Arguments.of(cycleway(), cyclewayAbsent, NONE),
- Arguments.of(cycleway(), moreThanFourLanes, NONE),
- Arguments.of(carTunnel(), moreThanFourLanes, NONE),
- Arguments.of(pedestrianTunnel(), moreThanFourLanes, NONE),
- Arguments.of(fiveLanes(), moreThanFourLanes, EXACT),
- Arguments.of(fiveLanes(), lessThanFourLanes, NONE),
- Arguments.of(threeLanes(), lessThanFourLanes, EXACT),
- Arguments.of(carTunnel(), lessThanFourLanes, NONE),
- Arguments.of(cycleway(), lessThanFourLanes, NONE),
- Arguments.of(fiveLanes(), betweenFiveAndThreeLanes, EXACT),
- Arguments.of(threeLanes(), betweenFiveAndThreeLanes, EXACT),
- Arguments.of(veryBadSmoothness(), smoothnessBadAndWorseThanBad, EXACT),
- Arguments.of(cobblestones(), smoothnessBadAndWorseThanBad, NONE),
- Arguments.of(excellentSmoothness(), smoothnessBadAndWorseThanBad, NONE),
- Arguments.of(noSidewalk(), noSidewalk, EXACT),
- Arguments.of(highwayTertiary(), noSidewalk, EXACT),
- Arguments.of(sidewalkBoth(), noSidewalk, NONE)
- );
+ static Stream otherCases() {
+ return Stream.of(
+ Arguments.of(cycleway(), cyclewayPresent, WILDCARD),
+ Arguments.of(carTunnel(), cyclewayPresent, NONE),
+ Arguments.of(carTunnel(), cyclewayAbsent, EXACT),
+ Arguments.of(cobblestones(), cyclewayAbsent, EXACT),
+ Arguments.of(cycleway(), cyclewayAbsent, NONE),
+ Arguments.of(cycleway(), moreThanFourLanes, NONE),
+ Arguments.of(carTunnel(), moreThanFourLanes, NONE),
+ Arguments.of(pedestrianTunnel(), moreThanFourLanes, NONE),
+ Arguments.of(fiveLanes(), moreThanFourLanes, EXACT),
+ Arguments.of(fiveLanes(), lessThanFourLanes, NONE),
+ Arguments.of(threeLanes(), lessThanFourLanes, EXACT),
+ Arguments.of(carTunnel(), lessThanFourLanes, NONE),
+ Arguments.of(cycleway(), lessThanFourLanes, NONE),
+ Arguments.of(fiveLanes(), betweenFiveAndThreeLanes, EXACT),
+ Arguments.of(threeLanes(), betweenFiveAndThreeLanes, EXACT),
+ Arguments.of(veryBadSmoothness(), smoothnessBadAndWorseThanBad, EXACT),
+ Arguments.of(cobblestones(), smoothnessBadAndWorseThanBad, NONE),
+ Arguments.of(excellentSmoothness(), smoothnessBadAndWorseThanBad, NONE),
+ Arguments.of(noSidewalk(), noSidewalk, EXACT),
+ Arguments.of(highwayTertiary(), noSidewalk, EXACT),
+ Arguments.of(sidewalkBoth(), noSidewalk, NONE)
+ );
+ }
@ParameterizedTest(name = "way {0} with op {1} should have a result {2}")
- @VariableSource("otherCases")
+ @MethodSource("otherCases")
void otherTests(OSMWithTags way, Condition op, MatchResult expectation) {
assertEquals(expectation, op.match(way));
}
diff --git a/src/test/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPathsTest.java b/src/test/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPathsTest.java
index bf8e06a73d7..8611a046a5b 100644
--- a/src/test/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPathsTest.java
+++ b/src/test/java/org/opentripplanner/raptor/rangeraptor/transit/AccessPathsTest.java
@@ -83,7 +83,7 @@ void calculateMaxNumberOfRides() {
}
@Test
- void iterateOverPathsWithPenalty() {
+ void iterateOverPathsWithTimePenalty() {
// Expected at departure 540
var flexFastWithPenalty = FLEX_FAST.withTimePenalty(60);
@@ -113,6 +113,25 @@ void iterateOverPathsWithPenalty() {
FORWARD
);
+ // Make sure standard iterator works
+ expect(
+ accessPaths.arrivedOnStreetByNumOfRides(0),
+ WALK_B,
+ walkFastWithPenalty,
+ walkCostWithPenalty
+ );
+ expect(accessPaths.arrivedOnBoardByNumOfRides(1));
+ expect(accessPaths.arrivedOnStreetByNumOfRides(1));
+ expect(accessPaths.arrivedOnBoardByNumOfRides(2), flexTxWithPenalty);
+ expect(accessPaths.arrivedOnStreetByNumOfRides(2), FLEX_WALK_B);
+ expect(
+ accessPaths.arrivedOnBoardByNumOfRides(3),
+ FLEX_B,
+ flexFastWithPenalty,
+ flexCostWithPenalty
+ );
+ expect(accessPaths.arrivedOnStreetByNumOfRides(3));
+
var iterator = accessPaths.iterateOverPathsWithPenalty(600);
// First iteration
@@ -146,7 +165,7 @@ void iterateOverPathsWithPenalty() {
}
@Test
- void iterateOverPathsWithPenaltyInReversDirection() {
+ void iterateOverPathsWithTimePenaltyInReversDirection() {
// Expected at departure 540
var flexFastWithPenalty = FLEX_FAST.withTimePenalty(60);
@@ -164,6 +183,10 @@ void iterateOverPathsWithPenaltyInReversDirection() {
REVERSE
);
+ // Make sure standard iterator works
+ expect(accessPaths.arrivedOnStreetByNumOfRides(0), WALK_B, walkFastWithPenalty);
+ expect(accessPaths.arrivedOnBoardByNumOfRides(3), FLEX_B, flexFastWithPenalty);
+
var iterator = accessPaths.iterateOverPathsWithPenalty(600);
// First iteration
@@ -196,6 +219,34 @@ void iterateOverPathsWithPenaltyInReversDirection() {
assertFalse(iterator.hasNext());
}
+ @Test
+ void testRegularIteratorsAndIteratorWithPenaltyWorksTogether() {
+ var walkFastWithPenalty = WALK_FAST.withTimePenalty(60);
+
+ // Without time-penalty, the iterator should be empty
+ var accessPaths = AccessPaths.create(
+ 60,
+ List.of(walkFastWithPenalty, WALK_COST),
+ MULTI_CRITERIA,
+ FORWARD
+ );
+
+ // Both accesses are expected before with enter the "time-penalty" iteration
+ expect(accessPaths.arrivedOnStreetByNumOfRides(0), WALK_COST, walkFastWithPenalty);
+ expect(accessPaths.arrivedOnBoardByNumOfRides(0));
+
+ var iterator = accessPaths.iterateOverPathsWithPenalty(600);
+
+ // First iteration - only access with time-penalty is expected
+ assertTrue(iterator.hasNext());
+ assertEquals(540, iterator.next());
+ expect(accessPaths.arrivedOnStreetByNumOfRides(0), walkFastWithPenalty);
+ expect(accessPaths.arrivedOnBoardByNumOfRides(0));
+
+ // Second iteration - Done
+ assertFalse(iterator.hasNext());
+ }
+
@Test
void hasTimeDependentAccess() {
var accessPaths = AccessPaths.create(
diff --git a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/TripPatternForDateTest.java b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/TripPatternForDateTest.java
index ecd75f5d273..dd9a2fffa66 100644
--- a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/TripPatternForDateTest.java
+++ b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/TripPatternForDateTest.java
@@ -8,9 +8,9 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.model.Frequency;
import org.opentripplanner.model.StopTime;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.framework.Deduplicator;
import org.opentripplanner.transit.model.network.Route;
@@ -33,12 +33,14 @@ class TripPatternForDateTest {
new Deduplicator()
);
- static Stream testCases = Stream
- .of(List.of(new FrequencyEntry(new Frequency(), tripTimes)), List.of())
- .map(Arguments::of);
+ static Stream testCases() {
+ return Stream
+ .of(List.of(new FrequencyEntry(new Frequency(), tripTimes)), List.of())
+ .map(Arguments::of);
+ }
@ParameterizedTest(name = "trip with frequencies {0} should be correctly filtered")
- @VariableSource("testCases")
+ @MethodSource("testCases")
void shouldExcludeAndIncludeBasedOnFrequency(List freqs) {
var stopTime = new StopTime();
stopTime.setStop(STOP);
diff --git a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/cost/WheelchairCostCalculatorTest.java b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/cost/WheelchairCostCalculatorTest.java
index 0c2384ebabb..b7d3f255a9d 100644
--- a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/cost/WheelchairCostCalculatorTest.java
+++ b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/cost/WheelchairCostCalculatorTest.java
@@ -5,11 +5,11 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.raptor._data.transit.TestTripSchedule;
import org.opentripplanner.raptor.api.model.RaptorTransferConstraint;
import org.opentripplanner.raptor.spi.RaptorCostCalculator;
import org.opentripplanner.routing.api.request.preference.AccessibilityPreferences;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model.basic.Accessibility;
public class WheelchairCostCalculatorTest {
@@ -34,14 +34,16 @@ public class WheelchairCostCalculatorTest {
);
private final TestTripSchedule.Builder scheduleBuilder = TestTripSchedule.schedule("12:00 12:01");
- static Stream testCases = Stream.of(
- Arguments.of(Accessibility.POSSIBLE, 0),
- Arguments.of(Accessibility.NO_INFORMATION, UNKNOWN_ACCESSIBILITY_COST),
- Arguments.of(Accessibility.NOT_POSSIBLE, INACCESSIBLE_TRIP_COST)
- );
+ static Stream testCases() {
+ return Stream.of(
+ Arguments.of(Accessibility.POSSIBLE, 0),
+ Arguments.of(Accessibility.NO_INFORMATION, UNKNOWN_ACCESSIBILITY_COST),
+ Arguments.of(Accessibility.NOT_POSSIBLE, INACCESSIBLE_TRIP_COST)
+ );
+ }
@ParameterizedTest(name = "accessibility of {0} should add an extra cost of {1}")
- @VariableSource("testCases")
+ @MethodSource("testCases")
public void calculateExtraBoardingCost(Accessibility wcb, int expectedExtraCost) {
var schedule = scheduleBuilder.wheelchairBoarding(wcb).build();
diff --git a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/request/RouteRequestTransitDataProviderFilterTest.java b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/request/RouteRequestTransitDataProviderFilterTest.java
index 4823ea84300..be6266ccdbe 100644
--- a/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/request/RouteRequestTransitDataProviderFilterTest.java
+++ b/src/test/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/request/RouteRequestTransitDataProviderFilterTest.java
@@ -13,6 +13,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.opentripplanner.apis.transmodel.model.TransmodelTransportSubmode;
import org.opentripplanner.framework.geometry.WgsCoordinate;
@@ -25,7 +26,6 @@
import org.opentripplanner.routing.api.request.request.filter.SelectRequest;
import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
import org.opentripplanner.routing.api.request.request.filter.TransitFilterRequest;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.basic.Accessibility;
import org.opentripplanner.transit.model.basic.MainAndSubMode;
@@ -70,14 +70,16 @@ class RouteRequestTransitDataProviderFilterTest {
.withElevator(RELAXED_ACCESSIBILITY_PREFERENCE)
.build();
- static Stream wheelchairCases = Stream.of(
- Arguments.of(Accessibility.POSSIBLE, DEFAULT_ACCESSIBILITY),
- Arguments.of(Accessibility.POSSIBLE, RELAXED_ACCESSIBILITY),
- Arguments.of(Accessibility.NOT_POSSIBLE, DEFAULT_ACCESSIBILITY),
- Arguments.of(Accessibility.NOT_POSSIBLE, RELAXED_ACCESSIBILITY),
- Arguments.of(Accessibility.NO_INFORMATION, DEFAULT_ACCESSIBILITY),
- Arguments.of(Accessibility.NO_INFORMATION, RELAXED_ACCESSIBILITY)
- );
+ static Stream wheelchairCases() {
+ return Stream.of(
+ Arguments.of(Accessibility.POSSIBLE, DEFAULT_ACCESSIBILITY),
+ Arguments.of(Accessibility.POSSIBLE, RELAXED_ACCESSIBILITY),
+ Arguments.of(Accessibility.NOT_POSSIBLE, DEFAULT_ACCESSIBILITY),
+ Arguments.of(Accessibility.NOT_POSSIBLE, RELAXED_ACCESSIBILITY),
+ Arguments.of(Accessibility.NO_INFORMATION, DEFAULT_ACCESSIBILITY),
+ Arguments.of(Accessibility.NO_INFORMATION, RELAXED_ACCESSIBILITY)
+ );
+ }
/**
* Test filter for wheelchair access.
@@ -85,7 +87,7 @@ class RouteRequestTransitDataProviderFilterTest {
* @param wheelchair Accessibility for stops
*/
@ParameterizedTest
- @VariableSource("wheelchairCases")
+ @MethodSource("wheelchairCases")
void testWheelchairAccess(Accessibility wheelchair, WheelchairPreferences accessibility) {
var firstStop = stopForTest("TEST:START", wheelchair, 0.0, 0.0);
var lastStop = stopForTest("TEST:END", wheelchair, 0.0, 0.0);
diff --git a/src/test/java/org/opentripplanner/routing/algorithm/transferoptimization/services/TransferGeneratorTest.java b/src/test/java/org/opentripplanner/routing/algorithm/transferoptimization/services/TransferGeneratorTest.java
index 230097ebfc3..4283e5cca62 100644
--- a/src/test/java/org/opentripplanner/routing/algorithm/transferoptimization/services/TransferGeneratorTest.java
+++ b/src/test/java/org/opentripplanner/routing/algorithm/transferoptimization/services/TransferGeneratorTest.java
@@ -15,6 +15,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.time.TimeUtils;
import org.opentripplanner.model.transfer.TransferConstraint;
import org.opentripplanner.raptor._data.RaptorTestConstants;
@@ -28,7 +29,6 @@
import org.opentripplanner.raptor.api.path.TransitPathLeg;
import org.opentripplanner.raptor.spi.DefaultSlackProvider;
import org.opentripplanner.raptor.spi.RaptorSlackProvider;
-import org.opentripplanner.test.support.VariableSource;
public class TransferGeneratorTest implements RaptorTestConstants {
@@ -497,24 +497,26 @@ void findTransferWithLongMinTimeTransfer() {
// TODO: here we check that minimum transfer time and slack are NOT added up, but perhaps that is
// asserting the wrong behaviour
- static Stream minTransferTimeSlackCases = Stream.of(
- // transfer takes 1 min plus 0 slack, passenger will make it
- Arguments.of(ofMinutes(1), ofMinutes(0), true),
- // slack is 30 minutes, passenger won't make the connection
- Arguments.of(ofMinutes(1), ofMinutes(30), false),
- // tight since 8 minutes slack + 1 min transfer time but still less than the 10 minutes required
- Arguments.of(ofMinutes(1), ofMinutes(8), true),
- // transfer slack is ignored since minimumTransferTime is short
- Arguments.of(ofMinutes(1), ofMinutes(9), true),
- Arguments.of(ofMinutes(11), ofMinutes(0), false),
- Arguments.of(ofMinutes(9), ofMinutes(1), true),
- Arguments.of(ofMinutes(0), ofMinutes(11), false)
- );
+ static Stream minTransferTimeSlackCases() {
+ return Stream.of(
+ // transfer takes 1 min plus 0 slack, passenger will make it
+ Arguments.of(ofMinutes(1), ofMinutes(0), true),
+ // slack is 30 minutes, passenger won't make the connection
+ Arguments.of(ofMinutes(1), ofMinutes(30), false),
+ // tight since 8 minutes slack + 1 min transfer time but still less than the 10 minutes required
+ Arguments.of(ofMinutes(1), ofMinutes(8), true),
+ // transfer slack is ignored since minimumTransferTime is short
+ Arguments.of(ofMinutes(1), ofMinutes(9), true),
+ Arguments.of(ofMinutes(11), ofMinutes(0), false),
+ Arguments.of(ofMinutes(9), ofMinutes(1), true),
+ Arguments.of(ofMinutes(0), ofMinutes(11), false)
+ );
+ }
@ParameterizedTest(
name = "minimum transfer time of {0}, transfer slack of {1} should expectTransfer={2} on 10 min transfer window"
)
- @VariableSource("minTransferTimeSlackCases")
+ @MethodSource("minTransferTimeSlackCases")
void includeTransferSlackInMinimumTransferTime(
Duration minTransferTime,
Duration transferSlack,
diff --git a/src/test/java/org/opentripplanner/routing/api/request/WheelchairPreferencesTest.java b/src/test/java/org/opentripplanner/routing/api/request/WheelchairPreferencesTest.java
index 157235c4483..9dd533704c7 100644
--- a/src/test/java/org/opentripplanner/routing/api/request/WheelchairPreferencesTest.java
+++ b/src/test/java/org/opentripplanner/routing/api/request/WheelchairPreferencesTest.java
@@ -7,20 +7,22 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.preference.WheelchairPreferences;
-import org.opentripplanner.test.support.VariableSource;
class WheelchairPreferencesTest {
- static Stream roundingTestCases = Stream.of(
- Arguments.of(0.33333333333, 0.33, 0.333),
- Arguments.of(0.77777777777, 0.78, 0.778)
- );
+ static Stream roundingTestCases() {
+ return Stream.of(
+ Arguments.of(0.33333333333, 0.33, 0.333),
+ Arguments.of(0.77777777777, 0.78, 0.778)
+ );
+ }
@ParameterizedTest(
name = "Normalize value of {0} to rounded value {1} (maxSlope) and {2} (reluctance fields)"
)
- @VariableSource("roundingTestCases")
+ @MethodSource("roundingTestCases")
void testConstructorNormalization(double raw, double rounded2, double rounded3) {
var roundedRequest = WheelchairPreferences
.of()
@@ -39,41 +41,43 @@ void testConstructorNormalization(double raw, double rounded2, double rounded3)
assertEquals(roundedRequest.slopeExceededReluctance(), rounded2);
}
- static Stream toStringTestCases = Stream.of(
- Arguments.of(DEFAULT, "WheelchairPreferences{}"),
- Arguments.of(
- WheelchairPreferences.of().withElevatorOnlyAccessible().build(),
- "WheelchairPreferences{elevator: OnlyConsiderAccessible}"
- ),
- Arguments.of(
- WheelchairPreferences.of().withTrip(DEFAULT_COSTS).build(),
- "WheelchairPreferences{trip: AccessibilityPreferences{}}"
- ),
- Arguments.of(
- WheelchairPreferences.of().withTrip(it -> it.withInaccessibleCost(100)).build(),
- "WheelchairPreferences{trip: AccessibilityPreferences{inaccessibleCost: $100}}"
- ),
- Arguments.of(
- WheelchairPreferences.of().withTripCost(99, 100).build(),
- "WheelchairPreferences{trip: AccessibilityPreferences{unknownCost: $99, inaccessibleCost: $100}}"
- ),
- Arguments.of(
- WheelchairPreferences
- .of()
- .withTripCost(10, 100)
- .withStopCost(20, 200)
- .withElevatorCost(30, 300)
- .withInaccessibleStreetReluctance(1.0)
- .withMaxSlope(0.123)
- .withSlopeExceededReluctance(3)
- .withStairsReluctance(4)
- .build(),
- "WheelchairPreferences{trip: AccessibilityPreferences{unknownCost: $10, inaccessibleCost: $100}, stop: AccessibilityPreferences{unknownCost: $20, inaccessibleCost: $200}, elevator: AccessibilityPreferences{unknownCost: $30, inaccessibleCost: $300}, inaccessibleStreetReluctance: 1.0, maxSlope: 0.123, slopeExceededReluctance: 3.0, stairsReluctance: 4.0}"
- )
- );
+ static Stream toStringTestCases() {
+ return Stream.of(
+ Arguments.of(DEFAULT, "WheelchairPreferences{}"),
+ Arguments.of(
+ WheelchairPreferences.of().withElevatorOnlyAccessible().build(),
+ "WheelchairPreferences{elevator: OnlyConsiderAccessible}"
+ ),
+ Arguments.of(
+ WheelchairPreferences.of().withTrip(DEFAULT_COSTS).build(),
+ "WheelchairPreferences{trip: AccessibilityPreferences{}}"
+ ),
+ Arguments.of(
+ WheelchairPreferences.of().withTrip(it -> it.withInaccessibleCost(100)).build(),
+ "WheelchairPreferences{trip: AccessibilityPreferences{inaccessibleCost: $100}}"
+ ),
+ Arguments.of(
+ WheelchairPreferences.of().withTripCost(99, 100).build(),
+ "WheelchairPreferences{trip: AccessibilityPreferences{unknownCost: $99, inaccessibleCost: $100}}"
+ ),
+ Arguments.of(
+ WheelchairPreferences
+ .of()
+ .withTripCost(10, 100)
+ .withStopCost(20, 200)
+ .withElevatorCost(30, 300)
+ .withInaccessibleStreetReluctance(1.0)
+ .withMaxSlope(0.123)
+ .withSlopeExceededReluctance(3)
+ .withStairsReluctance(4)
+ .build(),
+ "WheelchairPreferences{trip: AccessibilityPreferences{unknownCost: $10, inaccessibleCost: $100}, stop: AccessibilityPreferences{unknownCost: $20, inaccessibleCost: $200}, elevator: AccessibilityPreferences{unknownCost: $30, inaccessibleCost: $300}, inaccessibleStreetReluctance: 1.0, maxSlope: 0.123, slopeExceededReluctance: 3.0, stairsReluctance: 4.0}"
+ )
+ );
+ }
@ParameterizedTest(name = "Verify toString() value is {1}")
- @VariableSource("toStringTestCases")
+ @MethodSource("toStringTestCases")
void testToString(WheelchairPreferences subject, String expected) {
assertEquals(expected, subject.toString());
}
diff --git a/src/test/java/org/opentripplanner/routing/api/request/framework/LinearFunctionSerializationTest.java b/src/test/java/org/opentripplanner/routing/api/request/framework/LinearFunctionSerializationTest.java
index 9701fb412cc..e1785db61b1 100644
--- a/src/test/java/org/opentripplanner/routing/api/request/framework/LinearFunctionSerializationTest.java
+++ b/src/test/java/org/opentripplanner/routing/api/request/framework/LinearFunctionSerializationTest.java
@@ -11,9 +11,9 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.time.DurationUtils;
import org.opentripplanner.test.support.TestTableParser;
-import org.opentripplanner.test.support.VariableSource;
class LinearFunctionSerializationTest {
@@ -21,25 +21,27 @@ class LinearFunctionSerializationTest {
private static final Duration D1h = Duration.ofSeconds(3600);
@SuppressWarnings("unused")
- static Stream parseTestCases = TestTableParser.of(
- """
- # INPUT || EXPECTED
- # || CONSTANT | COEFFICIENT
- 0+0t || 0s | 0.0
- 1+0.0111 t || 1s | 0.01
- 120 + 0.111 t || 2m | 0.11
- 120 + 0.111 t || 2m | 0.11
- 12.0 + 0 t || 12s | 0.0
- 2h3m + 1.111 t || 2h3m | 1.11
- 2h3m + 2.111 t || 2h3m | 2.1
- 3h + 5.111 t || 3h | 5.1
- 7m + 10.1 x || 7m | 10.0
- PT7s + 10.1 x || 7s | 10.0
- """
- );
+ static Stream parseTestCases() {
+ return TestTableParser.of(
+ """
+ # INPUT || EXPECTED
+ # || CONSTANT | COEFFICIENT
+ 0+0t || 0s | 0.0
+ 1+0.0111 t || 1s | 0.01
+ 120 + 0.111 t || 2m | 0.11
+ 120 + 0.111 t || 2m | 0.11
+ 12.0 + 0 t || 12s | 0.0
+ 2h3m + 1.111 t || 2h3m | 1.11
+ 2h3m + 2.111 t || 2h3m | 2.1
+ 3h + 5.111 t || 3h | 5.1
+ 7m + 10.1 x || 7m | 10.0
+ PT7s + 10.1 x || 7s | 10.0
+ """
+ );
+ }
@ParameterizedTest
- @VariableSource("parseTestCases")
+ @MethodSource("parseTestCases")
void parseTest(String input, String expectedConstant, double expectedCoefficient) {
Optional result = LinearFunctionSerialization.parse(
input,
diff --git a/src/test/java/org/opentripplanner/routing/api/request/preference/TimeSlopeSafetyTriangleTest.java b/src/test/java/org/opentripplanner/routing/api/request/preference/TimeSlopeSafetyTriangleTest.java
index 7b2fe416290..2ba7f2569e4 100644
--- a/src/test/java/org/opentripplanner/routing/api/request/preference/TimeSlopeSafetyTriangleTest.java
+++ b/src/test/java/org/opentripplanner/routing/api/request/preference/TimeSlopeSafetyTriangleTest.java
@@ -7,26 +7,28 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
public class TimeSlopeSafetyTriangleTest {
float DELTA = 0.001f;
@SuppressWarnings("unused")
- static Stream testCases = Stream.of(
- // Input: time | slope | safety || Expected: time | slope | safety
- Arguments.of(0.5, 0.3, 0.2, 0.5, 0.3, 0.2, "Exact"),
- Arguments.of(1d, 1d, 1d, 0.33, 0.33, 0.34, "Greater than 1"),
- Arguments.of(30d, 10d, 20d, 0.5, 0.17, 0.33, "Greater than 1 - big"),
- Arguments.of(1d, 0d, 0d, 1d, 0d, 0d, "Two zeros"),
- Arguments.of(0d, 0d, 0d, 0.33, 0.33, 0.34, "All zeros"),
- Arguments.of(0.1, -1d, -1d, 1d, 0d, 0d, "Less than zero"),
- Arguments.of(0d, 0.07, 0.93, 0d, 0.07, 0.93, "None precise round-off: " + (1.0 - 0.07))
- );
+ static Stream testCases() {
+ return Stream.of(
+ // Input: time | slope | safety || Expected: time | slope | safety
+ Arguments.of(0.5, 0.3, 0.2, 0.5, 0.3, 0.2, "Exact"),
+ Arguments.of(1d, 1d, 1d, 0.33, 0.33, 0.34, "Greater than 1"),
+ Arguments.of(30d, 10d, 20d, 0.5, 0.17, 0.33, "Greater than 1 - big"),
+ Arguments.of(1d, 0d, 0d, 1d, 0d, 0d, "Two zeros"),
+ Arguments.of(0d, 0d, 0d, 0.33, 0.33, 0.34, "All zeros"),
+ Arguments.of(0.1, -1d, -1d, 1d, 0d, 0d, "Less than zero"),
+ Arguments.of(0d, 0.07, 0.93, 0d, 0.07, 0.93, "None precise round-off: " + (1.0 - 0.07))
+ );
+ }
@ParameterizedTest(name = "Time/slope/safety: | {0} {1} {2} || {3} {4} {5} | {6}")
- @VariableSource("testCases")
+ @MethodSource("testCases")
public void test(
double inTime,
double inSlope,
diff --git a/src/test/java/org/opentripplanner/routing/core/MoneyTest.java b/src/test/java/org/opentripplanner/routing/core/MoneyTest.java
index 2323b396d5c..5f197708f1d 100644
--- a/src/test/java/org/opentripplanner/routing/core/MoneyTest.java
+++ b/src/test/java/org/opentripplanner/routing/core/MoneyTest.java
@@ -14,7 +14,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.transit.model.basic.Money;
class MoneyTest {
@@ -27,36 +27,40 @@ class MoneyTest {
private static final Money twoDollars = Money.usDollars(2);
static Money threeEuroTwelve = Money.euros(3.12f);
- static Stream testCases = Stream.of(
- of(oneDollar, Locale.US, "$1.00"),
- of(oneDollar, Locale.GERMANY, "1,00 $"),
- of(Money.euros(1), Locale.GERMANY, "1,00 €"),
- of(oneDollar, NORWEGIAN_BOKMAL, "USD 1,00"),
- //of(oneDollar, NORWEGIAN_NYNORSK, "1.00 USD"),
- of(hundredNOK, NORWEGIAN_BOKMAL, "kr 100,00")
- //of(hundredNOK, NORWEGIAN_NYNORSK, "100.00 kr")
- );
+ static Stream testCases() {
+ return Stream.of(
+ of(oneDollar, Locale.US, "$1.00"),
+ of(oneDollar, Locale.GERMANY, "1,00 $"),
+ of(Money.euros(1), Locale.GERMANY, "1,00 €"),
+ of(oneDollar, NORWEGIAN_BOKMAL, "USD 1,00"),
+ //of(oneDollar, NORWEGIAN_NYNORSK, "1.00 USD"),
+ of(hundredNOK, NORWEGIAN_BOKMAL, "kr 100,00")
+ //of(hundredNOK, NORWEGIAN_NYNORSK, "100.00 kr")
+ );
+ }
@ParameterizedTest(name = "{0} with locale {1} should localise to \"{2}\"")
- @VariableSource("testCases")
+ @MethodSource("testCases")
void localize(Money money, Locale locale, String expected) {
var localized = money.localize(locale);
assertEquals(expected, localized);
}
- static Stream amountCases = Stream.of(
- of(oneDollar, 1.0f),
- of(threeEuroTwelve, 3.12f),
- of(Money.euros(3.1f), 3.1f),
- of(Money.euros(999.99f), 999.99f),
- of(hundredNOK, 100.0f),
- // Yen doesn't have fractional digits
- of(yen(1000), 1000f),
- of(yen(9999), 9999f)
- );
+ static Stream amountCases() {
+ return Stream.of(
+ of(oneDollar, 1.0f),
+ of(threeEuroTwelve, 3.12f),
+ of(Money.euros(3.1f), 3.1f),
+ of(Money.euros(999.99f), 999.99f),
+ of(hundredNOK, 100.0f),
+ // Yen doesn't have fractional digits
+ of(yen(1000), 1000f),
+ of(yen(9999), 9999f)
+ );
+ }
@ParameterizedTest
- @VariableSource("amountCases")
+ @MethodSource("amountCases")
void fractionalAmount(Money money, float expected) {
var fractionalAmount = money.fractionalAmount();
assertEquals(expected, fractionalAmount.floatValue());
diff --git a/src/test/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeTest.java b/src/test/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeTest.java
index bff99800fdb..136caf31a5b 100644
--- a/src/test/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeTest.java
+++ b/src/test/java/org/opentripplanner/service/worldenvelope/model/WorldEnvelopeTest.java
@@ -5,6 +5,9 @@
import java.util.List;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.geometry.WgsCoordinate;
class WorldEnvelopeTest {
@@ -18,83 +21,102 @@ class WorldEnvelopeTest {
private static final int W60 = -60;
private static final int W170 = -170;
- private static final WorldEnvelope EAST = WorldEnvelope
- .of()
- .expandToIncludeStreetEntities(S10, E50)
- .expandToIncludeStreetEntities(S20, E160)
- .build();
- private static final WorldEnvelope WEST = WorldEnvelope
- .of()
- .expandToIncludeStreetEntities(N30, W60)
- .expandToIncludeStreetEntities(N40, W170)
- .build();
- private static final WorldEnvelope GREENWICH = WorldEnvelope
- .of()
- .expandToIncludeStreetEntities(N30, W60)
- .expandToIncludeStreetEntities(S10, E50)
- .build();
- private static final WorldEnvelope MERIDIAN_180 = WorldEnvelope
- .of()
- .expandToIncludeStreetEntities(N40, W170)
- .expandToIncludeStreetEntities(S20, E160)
- .build();
-
- @Test
- void testEast() {
- var expectedCenter = new WgsCoordinate(-15d, 105d);
-
- assertEquals(S20, EAST.lowerLeft().latitude());
- assertEquals(E50, EAST.lowerLeft().longitude());
- assertEquals(S10, EAST.upperRight().latitude());
- assertEquals(E160, EAST.upperRight().longitude());
- assertEquals(expectedCenter, EAST.meanCenter());
- assertEquals(expectedCenter, EAST.center());
- assertTrue(EAST.transitMedianCenter().isEmpty());
+ /**
+ * To make sure we cover all cases we add a case for each combination of:
+ * - latitude
+ * - south hemisphere
+ * - north hemisphere
+ * - both sides of the equator
+ * - longitude
+ * - east side of 0º (Greenwich)
+ * - west side of 0º
+ * - both sides of 0º
+ * - both sides of 180º
+ * Skip cases for North- and South-pole - not relevant - obscure cases)
+ */
+ static List testCases() {
+ return List.of(
+ // name, lower-lat, left-lon, upper-lat, right-lon, center-lat, center-lon
+ Arguments.of("South-East", S20, E50, S10, E160, -15d, 105d),
+ Arguments.of("Equator-East", S10, E50, N30, E160, 10d, 105d),
+ Arguments.of("North-East", N30, E50, N40, E160, 35d, 105d),
+ Arguments.of("South-West", S20, W170, S10, W60, -15d, -115d),
+ Arguments.of("Equator-West", S10, W170, N30, W60, 10d, -115d),
+ Arguments.of("North-West", N30, W170, N40, W60, 35d, -115d),
+ Arguments.of("North-Greenwich", N30, W60, N40, E50, 35d, -5d),
+ Arguments.of("Equator-Greenwich", S10, W60, N30, E50, 10d, -5d),
+ Arguments.of("South-Greenwich", S20, W60, S10, E50, -15d, -5d),
+ Arguments.of("North-180º", N30, E160, N40, W170, 35d, 175d),
+ Arguments.of("Equator-180º", S10, E160, N30, W170, 10d, 175d),
+ Arguments.of("South-180º", S20, E160, S10, W170, -15d, 175d)
+ );
}
- @Test
- void transitMedianCenter() {
- var expectedCenter = new WgsCoordinate(S10, E50);
+ @ParameterizedTest
+ @MethodSource("testCases")
+ void testWorldEnvelope(
+ String name,
+ double lowerLat,
+ double leftLon,
+ double upperLat,
+ double rightLon,
+ double centerLat,
+ double centerLon
+ ) {
+ // Add a point close to the center
+ var median = new WgsCoordinate(centerLat + 1.0, centerLon + 1.0);
- var subject = WorldEnvelope
+ // WorldEnvelope should normalize to lower-left and upper-right
+ // Add lower-right & upper-left the world-envelope
+ var subjectWithoutMedian = WorldEnvelope
+ .of()
+ .expandToIncludeStreetEntities(lowerLat, rightLon)
+ .expandToIncludeStreetEntities(upperLat, leftLon)
+ .build();
+ // Add the ~middle point between each corner of the envelope + median point
+ // We offset the one center value to the "other" side of the median by adding 2.0
+ var subjectWithMedian = WorldEnvelope
.of()
.expandToIncludeTransitEntities(
List.of(
- new WgsCoordinate(S10, E50),
- new WgsCoordinate(S20, E160),
- new WgsCoordinate(N40, W60)
+ new WgsCoordinate(upperLat, centerLon),
+ new WgsCoordinate(lowerLat, centerLon + 2d),
+ new WgsCoordinate(centerLat, rightLon),
+ new WgsCoordinate(centerLat + 2d, leftLon),
+ median
),
WgsCoordinate::latitude,
WgsCoordinate::longitude
)
.build();
- assertTrue(subject.transitMedianCenter().isPresent(), subject.transitMedianCenter().toString());
- assertEquals(expectedCenter, subject.transitMedianCenter().get());
- assertEquals(expectedCenter, subject.center());
- assertEquals(
- "WorldEnvelope{lowerLeft: (-20.0, -60.0), upperRight: (40.0, 160.0), meanCenter: (10.0, 50.0), transitMedianCenter: (-10.0, 50.0)}",
- subject.toString()
+ for (WorldEnvelope subject : List.of(subjectWithoutMedian, subjectWithMedian)) {
+ assertEquals(lowerLat, subject.lowerLeft().latitude(), name + " lower-latitude");
+ assertEquals(leftLon, subject.lowerLeft().longitude(), name + " left-longitude");
+ assertEquals(upperLat, subject.upperRight().latitude(), name + " upper-latitude");
+ assertEquals(rightLon, subject.upperRight().longitude(), name + " right-longitude");
+ assertEquals(centerLat, subject.meanCenter().latitude(), name + " center-latitude");
+ assertEquals(centerLon, subject.meanCenter().longitude(), name + " center-longitude");
+ }
+
+ assertTrue(
+ subjectWithoutMedian.medianCenter().isEmpty(),
+ "First envelope does not have a median"
);
+ assertTrue(subjectWithMedian.medianCenter().isPresent(), "Second envelope does have a median");
+ assertEquals(median, subjectWithMedian.medianCenter().get(), name + " median");
}
@Test
- void testToString() {
- assertEquals(
- "WorldEnvelope{lowerLeft: (-20.0, 50.0), upperRight: (-10.0, 160.0), meanCenter: (-15.0, 105.0)}",
- EAST.toString()
- );
- assertEquals(
- "WorldEnvelope{lowerLeft: (30.0, -170.0), upperRight: (40.0, -60.0), meanCenter: (35.0, -115.0)}",
- WEST.toString()
- );
- assertEquals(
- "WorldEnvelope{lowerLeft: (-10.0, -60.0), upperRight: (30.0, 50.0), meanCenter: (10.0, -5.0)}",
- GREENWICH.toString()
- );
+ void testWorldEnvelopeToString() {
assertEquals(
- "WorldEnvelope{lowerLeft: (-20.0, 160.0), upperRight: (40.0, -170.0), meanCenter: (10.0, 175.0)}",
- MERIDIAN_180.toString()
+ "WorldEnvelope{lowerLeft: (-10.0, -60.0), upperRight: (40.0, 50.0), meanCenter: (15.0, -5.0)}",
+ WorldEnvelope
+ .of()
+ .expandToIncludeStreetEntities(S10, E50)
+ .expandToIncludeStreetEntities(N40, W60)
+ .build()
+ .toString()
);
}
}
diff --git a/src/test/java/org/opentripplanner/standalone/config/routerequest/WheelchairConfigTest.java b/src/test/java/org/opentripplanner/standalone/config/routerequest/WheelchairConfigTest.java
index 98b18f45d05..64216e5d83f 100644
--- a/src/test/java/org/opentripplanner/standalone/config/routerequest/WheelchairConfigTest.java
+++ b/src/test/java/org/opentripplanner/standalone/config/routerequest/WheelchairConfigTest.java
@@ -11,59 +11,61 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.preference.AccessibilityPreferences;
-import org.opentripplanner.test.support.VariableSource;
class WheelchairConfigTest {
- static Stream mapAccessibilityPreferencesTestCases = Stream.of(
- Arguments.of(
- "default ofOnlyAccessible()",
- "{}",
- ofOnlyAccessible(),
- DEFAULT_COSTS,
- ofOnlyAccessible()
- ),
- Arguments.of("default cost", "{}", ofCost(100, 200), ofCost(100, 200), ofCost(100, 200)),
- Arguments.of(
- "onlyConsiderAccessible with default costs",
- "{\"onlyConsiderAccessible\": true}",
- DEFAULT_COSTS,
- DEFAULT_COSTS,
- ofOnlyAccessible()
- ),
- Arguments.of(
- "Default costs with default ofOnlyAccessible()",
- "{\"onlyConsiderAccessible\": false}",
- ofOnlyAccessible(),
- DEFAULT_COSTS,
- DEFAULT_COSTS
- ),
- Arguments.of(
- "Only unknownCost set with default ofOnlyAccessible()",
- "{\"unknownCost\": 100}",
- ofOnlyAccessible(),
- DEFAULT_COSTS,
- ofCost(100, DEFAULT_COSTS.inaccessibleCost())
- ),
- Arguments.of(
- "Only inaccessibleCost set with default ofOnlyAccessible()",
- "{\"inaccessibleCost\": 100}",
- ofOnlyAccessible(),
- DEFAULT_COSTS,
- ofCost(DEFAULT_COSTS.unknownCost(), 100)
- ),
- Arguments.of(
- "All values set",
- "{\"unknownCost\": 200, \"inaccessibleCost\": 100, \"onlyConsiderAccessible\": false}",
- ofOnlyAccessible(),
- DEFAULT_COSTS,
- ofCost(200, 100)
- )
- );
+ static Stream mapAccessibilityPreferencesTestCases() {
+ return Stream.of(
+ Arguments.of(
+ "default ofOnlyAccessible()",
+ "{}",
+ ofOnlyAccessible(),
+ DEFAULT_COSTS,
+ ofOnlyAccessible()
+ ),
+ Arguments.of("default cost", "{}", ofCost(100, 200), ofCost(100, 200), ofCost(100, 200)),
+ Arguments.of(
+ "onlyConsiderAccessible with default costs",
+ "{\"onlyConsiderAccessible\": true}",
+ DEFAULT_COSTS,
+ DEFAULT_COSTS,
+ ofOnlyAccessible()
+ ),
+ Arguments.of(
+ "Default costs with default ofOnlyAccessible()",
+ "{\"onlyConsiderAccessible\": false}",
+ ofOnlyAccessible(),
+ DEFAULT_COSTS,
+ DEFAULT_COSTS
+ ),
+ Arguments.of(
+ "Only unknownCost set with default ofOnlyAccessible()",
+ "{\"unknownCost\": 100}",
+ ofOnlyAccessible(),
+ DEFAULT_COSTS,
+ ofCost(100, DEFAULT_COSTS.inaccessibleCost())
+ ),
+ Arguments.of(
+ "Only inaccessibleCost set with default ofOnlyAccessible()",
+ "{\"inaccessibleCost\": 100}",
+ ofOnlyAccessible(),
+ DEFAULT_COSTS,
+ ofCost(DEFAULT_COSTS.unknownCost(), 100)
+ ),
+ Arguments.of(
+ "All values set",
+ "{\"unknownCost\": 200, \"inaccessibleCost\": 100, \"onlyConsiderAccessible\": false}",
+ ofOnlyAccessible(),
+ DEFAULT_COSTS,
+ ofCost(200, 100)
+ )
+ );
+ }
@ParameterizedTest(name = "{0}")
- @VariableSource("mapAccessibilityPreferencesTestCases")
+ @MethodSource("mapAccessibilityPreferencesTestCases")
void testMapAccessibilityPreferences(
String name,
String json,
diff --git a/src/test/java/org/opentripplanner/standalone/server/EtagRequestFilterTest.java b/src/test/java/org/opentripplanner/standalone/server/EtagRequestFilterTest.java
index 5adf8264d8e..ae19643db72 100644
--- a/src/test/java/org/opentripplanner/standalone/server/EtagRequestFilterTest.java
+++ b/src/test/java/org/opentripplanner/standalone/server/EtagRequestFilterTest.java
@@ -16,27 +16,29 @@
import org.jets3t.service.utils.Mimetypes;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.test.support.HttpForTest;
-import org.opentripplanner.test.support.VariableSource;
class EtagRequestFilterTest {
static final String vectorTilesResponse = "some vector tiles";
static final String vectorTilesEtag = "\"20c17790\"";
- static Stream etagCases = Stream.of(
- Arguments.of("GET", 200, APPLICATION_X_PROTOBUF, bytes(vectorTilesResponse), vectorTilesEtag),
- Arguments.of("GET", 404, APPLICATION_X_PROTOBUF, bytes("hello123"), null),
- Arguments.of("GET", 200, "application/json", bytes("{}"), null),
- Arguments.of("POST", 200, APPLICATION_X_PROTOBUF, bytes("hello123"), null),
- Arguments.of("GET", 200, APPLICATION_X_PROTOBUF, bytes(""), null),
- Arguments.of("POST", 200, Mimetypes.MIMETYPE_HTML, bytes(""), null)
- );
+ static Stream etagCases() {
+ return Stream.of(
+ Arguments.of("GET", 200, APPLICATION_X_PROTOBUF, bytes(vectorTilesResponse), vectorTilesEtag),
+ Arguments.of("GET", 404, APPLICATION_X_PROTOBUF, bytes("hello123"), null),
+ Arguments.of("GET", 200, "application/json", bytes("{}"), null),
+ Arguments.of("POST", 200, APPLICATION_X_PROTOBUF, bytes("hello123"), null),
+ Arguments.of("GET", 200, APPLICATION_X_PROTOBUF, bytes(""), null),
+ Arguments.of("POST", 200, Mimetypes.MIMETYPE_HTML, bytes(""), null)
+ );
+ }
@ParameterizedTest(
name = "{0} request with response status={1} type={2}, entity={3} produces ETag header {4}"
)
- @VariableSource("etagCases")
+ @MethodSource("etagCases")
void writeEtag(
String method,
int status,
@@ -56,13 +58,15 @@ void writeEtag(
assertEquals(expectedEtag, response.getHeaderString(EtagRequestFilter.HEADER_ETAG));
}
- static Stream ifNoneMatchCases = Stream.of(
- Arguments.of("XXX", 200, bytes(vectorTilesResponse)),
- Arguments.of(vectorTilesEtag, 304, null)
- );
+ static Stream ifNoneMatchCases() {
+ return Stream.of(
+ Arguments.of("XXX", 200, bytes(vectorTilesResponse)),
+ Arguments.of(vectorTilesEtag, 304, null)
+ );
+ }
@ParameterizedTest(name = "If-None-Match header of {0} should lead to a status code of {2}")
- @VariableSource("ifNoneMatchCases")
+ @MethodSource("ifNoneMatchCases")
void ifNoneMatch(String ifNoneMatch, int expectedStatus, byte[] expectedEntity)
throws IOException {
var request = HttpForTest.containerRequest("GET");
diff --git a/src/test/java/org/opentripplanner/standalone/server/RequestTraceFilterTest.java b/src/test/java/org/opentripplanner/standalone/server/RequestTraceFilterTest.java
index 126ca887cc3..8198444f6be 100644
--- a/src/test/java/org/opentripplanner/standalone/server/RequestTraceFilterTest.java
+++ b/src/test/java/org/opentripplanner/standalone/server/RequestTraceFilterTest.java
@@ -7,7 +7,7 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
-import org.opentripplanner.test.support.VariableSource;
+import org.junit.jupiter.params.provider.MethodSource;
class RequestTraceFilterTest {
@@ -19,22 +19,24 @@ class RequestTraceFilterTest {
private static final String A_TOO_LONG_STRING = A_VERY_LONG_STRING + "1";
@SuppressWarnings("unused")
- private static final Stream headerCheckTestCases = Stream.of(
- Arguments.of(true, "ok"),
- Arguments.of(true, "special characters: -_,;.:!#$%&/(){}[]=?+"),
- Arguments.of(true, "quote: \"quoted\" 'single' `back` ´forward´"),
- Arguments.of(true, "international characters: æøå öâò≈∰🧐"),
- Arguments.of(true, A_VERY_LONG_STRING),
- Arguments.of(false, A_TOO_LONG_STRING),
- Arguments.of(false, "Vertical space new-line: -\n-"),
- Arguments.of(false, "Vertical space return: -\r-"),
- Arguments.of(false, "Vertical space form-feed: -\f-"),
- Arguments.of(false, "Control character 0x01: -\u0001-"),
- Arguments.of(false, "Control character 0x19: -\u0019-")
- );
+ private static final Stream headerCheckTestCases() {
+ return Stream.of(
+ Arguments.of(true, "ok"),
+ Arguments.of(true, "special characters: -_,;.:!#$%&/(){}[]=?+"),
+ Arguments.of(true, "quote: \"quoted\" 'single' `back` ´forward´"),
+ Arguments.of(true, "international characters: æøå öâò≈∰🧐"),
+ Arguments.of(true, A_VERY_LONG_STRING),
+ Arguments.of(false, A_TOO_LONG_STRING),
+ Arguments.of(false, "Vertical space new-line: -\n-"),
+ Arguments.of(false, "Vertical space return: -\r-"),
+ Arguments.of(false, "Vertical space form-feed: -\f-"),
+ Arguments.of(false, "Control character 0x01: -\u0001-"),
+ Arguments.of(false, "Control character 0x19: -\u0019-")
+ );
+ }
@ParameterizedTest
- @VariableSource("headerCheckTestCases")
+ @MethodSource("headerCheckTestCases")
void headerCheck(boolean expectedMatch, String input) {
assertEquals(
expectedMatch,
diff --git a/src/test/java/org/opentripplanner/street/model/edge/ElevatorHopEdgeTest.java b/src/test/java/org/opentripplanner/street/model/edge/ElevatorHopEdgeTest.java
index 5d7c9d1213f..8efa6940d20 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/ElevatorHopEdgeTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/ElevatorHopEdgeTest.java
@@ -8,13 +8,13 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.preference.AccessibilityPreferences;
import org.opentripplanner.routing.api.request.preference.WheelchairPreferences;
import org.opentripplanner.street.model.StreetTraversalPermission;
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model.basic.Accessibility;
class ElevatorHopEdgeTest {
@@ -22,12 +22,12 @@ class ElevatorHopEdgeTest {
Vertex from = intersectionVertex(0, 0);
Vertex to = intersectionVertex(1, 1);
- static Stream noTraverse = Stream
- .of(Accessibility.NO_INFORMATION, Accessibility.NOT_POSSIBLE)
- .map(Arguments::of);
+ static Stream noTraverse() {
+ return Stream.of(Accessibility.NO_INFORMATION, Accessibility.NOT_POSSIBLE).map(Arguments::of);
+ }
@ParameterizedTest(name = "{0} should be allowed to traverse when requesting onlyAccessible")
- @VariableSource("noTraverse")
+ @MethodSource("noTraverse")
void shouldNotTraverse(Accessibility wheelchair) {
var req = StreetSearchRequest.of();
AccessibilityPreferences feature = AccessibilityPreferences.ofOnlyAccessible();
@@ -52,17 +52,19 @@ void shouldNotTraverse(Accessibility wheelchair) {
assertTrue(State.isEmpty(result));
}
- static Stream all = Stream.of(
- // no extra cost
- Arguments.of(Accessibility.POSSIBLE, 20),
- // low extra cost
- Arguments.of(Accessibility.NO_INFORMATION, 40),
- // high extra cost
- Arguments.of(Accessibility.NOT_POSSIBLE, 3620)
- );
+ static Stream all() {
+ return Stream.of(
+ // no extra cost
+ Arguments.of(Accessibility.POSSIBLE, 20),
+ // low extra cost
+ Arguments.of(Accessibility.NO_INFORMATION, 40),
+ // high extra cost
+ Arguments.of(Accessibility.NOT_POSSIBLE, 3620)
+ );
+ }
@ParameterizedTest(name = "{0} should allowed to traverse with a cost of {1}")
- @VariableSource("all")
+ @MethodSource("all")
void allowByDefault(Accessibility wheelchair, double expectedCost) {
var req = StreetSearchRequest.of().build();
var result = traverse(wheelchair, req)[0];
diff --git a/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java b/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
index 1c7fdba7ae7..60859290646 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
@@ -7,22 +7,24 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.model.vertex.SimpleVertex;
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
class EscalatorEdgeTest {
Vertex from = new SimpleVertex("A", 10, 10);
Vertex to = new SimpleVertex("B", 10.001, 10.001);
- static Stream args = Stream.of(Arguments.of(1.5, 150), Arguments.of(3.0, 300));
+ static Stream args() {
+ return Stream.of(Arguments.of(1.5, 150), Arguments.of(3.0, 300));
+ }
@ParameterizedTest(name = "escalatorReluctance of {0} should lead to traversal costs of {1}")
- @VariableSource("args")
+ @MethodSource("args")
void testWalking(double escalatorReluctance, double expectedWeight) {
var edge = EscalatorEdge.createEscalatorEdge(from, to, 45);
var req = StreetSearchRequest
diff --git a/src/test/java/org/opentripplanner/street/model/edge/PathwayEdgeTest.java b/src/test/java/org/opentripplanner/street/model/edge/PathwayEdgeTest.java
index 9d4b1ff4fe2..6929f665938 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/PathwayEdgeTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/PathwayEdgeTest.java
@@ -12,6 +12,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.i18n.I18NString;
import org.opentripplanner.framework.i18n.NonLocalizedString;
import org.opentripplanner.routing.api.request.StreetMode;
@@ -19,7 +20,6 @@
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model.site.PathwayMode;
class PathwayEdgeTest {
@@ -141,20 +141,22 @@ void wheelchair() {
assertEquals(300.0, state.getWeight());
}
- static Stream slopeCases = Stream.of(
- // no extra cost
- Arguments.of(0.07, 120),
- // no extra cost
- Arguments.of(0.08, 120),
- // 1 % above max
- Arguments.of(0.09, 239),
- // 1.1 % above the max slope, tiny extra cost
- Arguments.of(0.091, 251),
- // 1.15 % above the max slope, will incur larger cost
- Arguments.of(0.0915, 257),
- // 3 % above max slope, will incur very large cost
- Arguments.of(0.11, 480)
- );
+ static Stream slopeCases() {
+ return Stream.of(
+ // no extra cost
+ Arguments.of(0.07, 120),
+ // no extra cost
+ Arguments.of(0.08, 120),
+ // 1 % above max
+ Arguments.of(0.09, 239),
+ // 1.1 % above the max slope, tiny extra cost
+ Arguments.of(0.091, 251),
+ // 1.15 % above the max slope, will incur larger cost
+ Arguments.of(0.0915, 257),
+ // 3 % above max slope, will incur very large cost
+ Arguments.of(0.11, 480)
+ );
+ }
/**
* This makes sure that when you exceed the max slope in a wheelchair there isn't a hard cut-off
@@ -164,7 +166,7 @@ void wheelchair() {
* dramatically to the point where it's only used as a last resort.
*/
@ParameterizedTest(name = "slope of {0} should lead to traversal costs of {1}")
- @VariableSource("slopeCases")
+ @MethodSource("slopeCases")
void shouldScaleCostWithMaxSlope(double slope, long expectedCost) {
var edge = PathwayEdge.createPathwayEdge(
from,
diff --git a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeCostTest.java b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeCostTest.java
index 2ecfa51822a..acd02653941 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeCostTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeCostTest.java
@@ -8,23 +8,25 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.model.StreetTraversalPermission;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
class StreetEdgeCostTest {
- static Stream walkReluctanceCases = Stream.of(
- Arguments.of(0.5, 37),
- Arguments.of(1, 75),
- Arguments.of(2, 150),
- Arguments.of(3, 225)
- );
+ static Stream walkReluctanceCases() {
+ return Stream.of(
+ Arguments.of(0.5, 37),
+ Arguments.of(1, 75),
+ Arguments.of(2, 150),
+ Arguments.of(3, 225)
+ );
+ }
@ParameterizedTest(name = "walkRelucance of {0} should lead to traversal costs of {1}")
- @VariableSource("walkReluctanceCases")
+ @MethodSource("walkReluctanceCases")
public void walkReluctance(double walkReluctance, long expectedCost) {
double length = 100;
var edge = new StreetEdgeBuilder<>()
@@ -45,15 +47,17 @@ public void walkReluctance(double walkReluctance, long expectedCost) {
assertEquals(76, result.getElapsedTimeSeconds());
}
- static Stream bikeReluctanceCases = Stream.of(
- Arguments.of(0.5, 10),
- Arguments.of(1, 20),
- Arguments.of(2, 40),
- Arguments.of(3, 60)
- );
+ static Stream bikeReluctanceCases() {
+ return Stream.of(
+ Arguments.of(0.5, 10),
+ Arguments.of(1, 20),
+ Arguments.of(2, 40),
+ Arguments.of(3, 60)
+ );
+ }
@ParameterizedTest(name = "bikeReluctance of {0} should lead to traversal costs of {1}")
- @VariableSource("bikeReluctanceCases")
+ @MethodSource("bikeReluctanceCases")
public void bikeReluctance(double bikeReluctance, long expectedCost) {
double length = 100;
var edge = new StreetEdgeBuilder<>()
@@ -75,15 +79,17 @@ public void bikeReluctance(double bikeReluctance, long expectedCost) {
assertEquals(20, result.getElapsedTimeSeconds());
}
- static Stream carReluctanceCases = Stream.of(
- Arguments.of(0.5, 4),
- Arguments.of(1, 8),
- Arguments.of(2, 17),
- Arguments.of(3, 26)
- );
+ static Stream carReluctanceCases() {
+ return Stream.of(
+ Arguments.of(0.5, 4),
+ Arguments.of(1, 8),
+ Arguments.of(2, 17),
+ Arguments.of(3, 26)
+ );
+ }
@ParameterizedTest(name = "carReluctance of {0} should lead to traversal costs of {1}")
- @VariableSource("carReluctanceCases")
+ @MethodSource("carReluctanceCases")
public void carReluctance(double carReluctance, long expectedCost) {
double length = 100;
var edge = new StreetEdgeBuilder<>()
@@ -105,14 +111,12 @@ public void carReluctance(double carReluctance, long expectedCost) {
assertEquals(9, result.getElapsedTimeSeconds());
}
- static Stream stairsCases = Stream.of(
- Arguments.of(1, 22),
- Arguments.of(1.5, 33),
- Arguments.of(3, 67)
- );
+ static Stream stairsCases() {
+ return Stream.of(Arguments.of(1, 22), Arguments.of(1.5, 33), Arguments.of(3, 67));
+ }
@ParameterizedTest(name = "stairs reluctance of {0} should lead to traversal costs of {1}")
- @VariableSource("stairsCases")
+ @MethodSource("stairsCases")
public void stairsReluctance(double stairsReluctance, long expectedCost) {
double length = 10;
var stairsEdge = new StreetEdgeBuilder<>()
@@ -138,14 +142,12 @@ public void stairsReluctance(double stairsReluctance, long expectedCost) {
assertEquals(15, (long) notStairsResult.weight);
}
- static Stream bikeStairsCases = Stream.of(
- Arguments.of(1, 45),
- Arguments.of(1.5, 67),
- Arguments.of(3, 135)
- );
+ static Stream bikeStairsCases() {
+ return Stream.of(Arguments.of(1, 45), Arguments.of(1.5, 67), Arguments.of(3, 135));
+ }
@ParameterizedTest(name = "bike stairs reluctance of {0} should lead to traversal costs of {1}")
- @VariableSource("bikeStairsCases")
+ @MethodSource("bikeStairsCases")
public void bikeStairsReluctance(double stairsReluctance, long expectedCost) {
double length = 10;
var stairsEdge = new StreetEdgeBuilder<>()
@@ -173,14 +175,12 @@ public void bikeStairsReluctance(double stairsReluctance, long expectedCost) {
assertEquals(37, (long) notStairsResult.weight);
}
- static Stream walkSafetyCases = Stream.of(
- Arguments.of(0, 15),
- Arguments.of(0.5, 22),
- Arguments.of(1, 30)
- );
+ static Stream walkSafetyCases() {
+ return Stream.of(Arguments.of(0, 15), Arguments.of(0.5, 22), Arguments.of(1, 30));
+ }
@ParameterizedTest(name = "walk safety factor of {0} should lead to traversal costs of {1}")
- @VariableSource("walkSafetyCases")
+ @MethodSource("walkSafetyCases")
public void walkSafetyFactor(double walkSafetyFactor, long expectedCost) {
double length = 10;
var safeEdge = new StreetEdgeBuilder<>()
diff --git a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeRentalTraversalTest.java b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeRentalTraversalTest.java
index 20682b6048b..44de661f327 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeRentalTraversalTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeRentalTraversalTest.java
@@ -17,6 +17,7 @@
import javax.annotation.Nonnull;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.model.RentalFormFactor;
import org.opentripplanner.street.model.StreetTraversalPermission;
@@ -24,7 +25,6 @@
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
import org.opentripplanner.street.search.state.StateEditor;
-import org.opentripplanner.test.support.VariableSource;
public class StreetEdgeRentalTraversalTest {
@@ -42,18 +42,20 @@ private static Stream baseCases(StreetTraversalPermission p) {
);
}
- static Stream allowedToTraverse = Stream
- .of(
- StreetTraversalPermission.ALL,
- StreetTraversalPermission.PEDESTRIAN_AND_BICYCLE,
- StreetTraversalPermission.BICYCLE
- )
- .flatMap(StreetEdgeRentalTraversalTest::baseCases);
+ static Stream allowedToTraverse() {
+ return Stream
+ .of(
+ StreetTraversalPermission.ALL,
+ StreetTraversalPermission.PEDESTRIAN_AND_BICYCLE,
+ StreetTraversalPermission.BICYCLE
+ )
+ .flatMap(StreetEdgeRentalTraversalTest::baseCases);
+ }
@ParameterizedTest(
name = "Form factor {0}, street mode {1} should be able to traverse edge with permission {2}"
)
- @VariableSource("allowedToTraverse")
+ @MethodSource("allowedToTraverse")
void scooterBicycleTraversal(
RentalFormFactor formFactor,
StreetMode streetMode,
@@ -74,14 +76,16 @@ void scooterBicycleTraversal(
assertEquals(formFactor.traverseMode, afterTraversal.currentMode());
}
- static Stream noTraversal = Stream
- .of(StreetTraversalPermission.CAR, StreetTraversalPermission.NONE)
- .flatMap(StreetEdgeRentalTraversalTest::baseCases);
+ static Stream noTraversal() {
+ return Stream
+ .of(StreetTraversalPermission.CAR, StreetTraversalPermission.NONE)
+ .flatMap(StreetEdgeRentalTraversalTest::baseCases);
+ }
@ParameterizedTest(
name = "Form factor {0}, street mode {1} should not be able to traverse edge with permission {2}"
)
- @VariableSource("noTraversal")
+ @MethodSource("noTraversal")
void noTraversal(
RentalFormFactor formFactor,
StreetMode streetMode,
diff --git a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeWheelchairCostTest.java b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeWheelchairCostTest.java
index ed4b92da779..7c2767a6935 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeWheelchairCostTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/StreetEdgeWheelchairCostTest.java
@@ -7,6 +7,7 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.impl.PackedCoordinateSequence;
import org.opentripplanner.routing.api.request.preference.WheelchairPreferences;
@@ -14,7 +15,6 @@
import org.opentripplanner.street.model.vertex.StreetVertex;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
class StreetEdgeWheelchairCostTest {
@@ -26,26 +26,28 @@ public StreetEdgeWheelchairCostTest() {
V2 = intersectionVertex("V2", 2.0, 0.0);
}
- static Stream slopeCases = Stream.of(
- // no extra cost
- Arguments.of(0.07, 1, 5081),
- // no extra cost
- Arguments.of(0.08, 1, 5945),
- // no extra cost
- Arguments.of(0.09, 1, 6908),
- // 0.1 % above the max slope, tiny extra cost
- Arguments.of(0.091, 1, 7708),
- // 3 % above max slope, will incur very large cost
- Arguments.of(0.091, 3, 9110),
- // 0.1 % above the max slope, but high reluctance will large cost
- Arguments.of(0.0915, 1, 8116),
- // 2 % above max slope, but lowered reluctance
- Arguments.of(0.11, 0.5, 17649),
- // 2 % above max slope, will incur very large cost
- Arguments.of(0.11, 1, 26474),
- // 3 % above max slope, will incur very large cost
- Arguments.of(0.12, 1, 37978)
- );
+ static Stream slopeCases() {
+ return Stream.of(
+ // no extra cost
+ Arguments.of(0.07, 1, 5081),
+ // no extra cost
+ Arguments.of(0.08, 1, 5945),
+ // no extra cost
+ Arguments.of(0.09, 1, 6908),
+ // 0.1 % above the max slope, tiny extra cost
+ Arguments.of(0.091, 1, 7708),
+ // 3 % above max slope, will incur very large cost
+ Arguments.of(0.091, 3, 9110),
+ // 0.1 % above the max slope, but high reluctance will large cost
+ Arguments.of(0.0915, 1, 8116),
+ // 2 % above max slope, but lowered reluctance
+ Arguments.of(0.11, 0.5, 17649),
+ // 2 % above max slope, will incur very large cost
+ Arguments.of(0.11, 1, 26474),
+ // 3 % above max slope, will incur very large cost
+ Arguments.of(0.12, 1, 37978)
+ );
+ }
/**
* This makes sure that when you exceed the max slope in a wheelchair there isn't a hard cut-off
@@ -57,7 +59,7 @@ public StreetEdgeWheelchairCostTest() {
@ParameterizedTest(
name = "slope of {0} with maxSlopeExceededReluctance of {1} should lead to traversal costs of {2}"
)
- @VariableSource("slopeCases")
+ @MethodSource("slopeCases")
public void shouldScaleCostWithMaxSlope(double slope, double reluctance, long expectedCost) {
double length = 1000;
var edge = new StreetEdgeBuilder<>()
@@ -104,16 +106,14 @@ public void shouldScaleCostWithMaxSlope(double slope, double reluctance, long ex
assertEquals(expectedCost, (long) result.weight);
}
- static Stream wheelchairStairsCases = Stream.of(
- Arguments.of(1, 22),
- Arguments.of(10, 225),
- Arguments.of(100, 2255)
- );
+ static Stream wheelchairStairsCases() {
+ return Stream.of(Arguments.of(1, 22), Arguments.of(10, 225), Arguments.of(100, 2255));
+ }
@ParameterizedTest(
name = "wheelchair stairs reluctance of {0} should lead to traversal costs of {1}"
)
- @VariableSource("wheelchairStairsCases")
+ @MethodSource("wheelchairStairsCases")
public void wheelchairStairsReluctance(double stairsReluctance, long expectedCost) {
double length = 10;
var stairEdge = new StreetEdgeBuilder<>()
@@ -153,16 +153,14 @@ public void wheelchairStairsReluctance(double stairsReluctance, long expectedCos
assertEquals(7, (long) notStairsResult.weight);
}
- static Stream inaccessibleStreetCases = Stream.of(
- Arguments.of(1f, 15),
- Arguments.of(10f, 150),
- Arguments.of(100f, 1503)
- );
+ static Stream inaccessibleStreetCases() {
+ return Stream.of(Arguments.of(1f, 15), Arguments.of(10f, 150), Arguments.of(100f, 1503));
+ }
@ParameterizedTest(
name = "an inaccessible street with the reluctance of {0} should lead to traversal costs of {1}"
)
- @VariableSource("inaccessibleStreetCases")
+ @MethodSource("inaccessibleStreetCases")
public void inaccessibleStreet(float inaccessibleStreetReluctance, long expectedCost) {
double length = 10;
var edge = new StreetEdgeBuilder<>()
@@ -201,17 +199,19 @@ public void inaccessibleStreet(float inaccessibleStreetReluctance, long expected
assertEquals(15, (long) accessibleResult.weight);
}
- static Stream walkReluctanceCases = Stream.of(
- Arguments.of(0.5, 3),
- Arguments.of(1, 7),
- Arguments.of(10, 75),
- Arguments.of(100, 751)
- );
+ static Stream walkReluctanceCases() {
+ return Stream.of(
+ Arguments.of(0.5, 3),
+ Arguments.of(1, 7),
+ Arguments.of(10, 75),
+ Arguments.of(100, 751)
+ );
+ }
@ParameterizedTest(
name = "walkReluctance of {0} should affect wheelchair users and lead to traversal costs of {1}"
)
- @VariableSource("walkReluctanceCases")
+ @MethodSource("walkReluctanceCases")
public void walkReluctance(double walkReluctance, long expectedCost) {
double length = 10;
var edge = new StreetEdgeBuilder<>()
diff --git a/src/test/java/org/opentripplanner/street/model/edge/StreetVehicleParkingLinkTest.java b/src/test/java/org/opentripplanner/street/model/edge/StreetVehicleParkingLinkTest.java
index a2a052d3b5c..99de720a5a2 100644
--- a/src/test/java/org/opentripplanner/street/model/edge/StreetVehicleParkingLinkTest.java
+++ b/src/test/java/org/opentripplanner/street/model/edge/StreetVehicleParkingLinkTest.java
@@ -11,6 +11,7 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.framework.geometry.WgsCoordinate;
import org.opentripplanner.framework.i18n.NonLocalizedString;
import org.opentripplanner.routing.api.request.StreetMode;
@@ -20,22 +21,23 @@
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.state.State;
-import org.opentripplanner.test.support.VariableSource;
class StreetVehicleParkingLinkTest {
- static Stream testCases = Stream.of(
- of(Set.of(), Set.of(), Set.of(), true),
- of(Set.of("a-tag"), Set.of(), Set.of(), true),
- of(Set.of("a"), Set.of("a"), Set.of(), false),
- of(Set.of("a"), Set.of("a"), Set.of("a"), false),
- of(Set.of("a", "b"), Set.of("b"), Set.of("a"), false),
- of(Set.of("a", "b"), Set.of(), Set.of("a"), true),
- of(Set.of("a", "b"), Set.of(), Set.of("c"), false)
- );
+ static Stream testCases() {
+ return Stream.of(
+ of(Set.of(), Set.of(), Set.of(), true),
+ of(Set.of("a-tag"), Set.of(), Set.of(), true),
+ of(Set.of("a"), Set.of("a"), Set.of(), false),
+ of(Set.of("a"), Set.of("a"), Set.of("a"), false),
+ of(Set.of("a", "b"), Set.of("b"), Set.of("a"), false),
+ of(Set.of("a", "b"), Set.of(), Set.of("a"), true),
+ of(Set.of("a", "b"), Set.of(), Set.of("c"), false)
+ );
+ }
@ParameterizedTest(name = "Parking[tags={0}], Request[not={1}, select={2}] should traverse={3}")
- @VariableSource("testCases")
+ @MethodSource("testCases")
void foo(Set parkingTags, Set not, Set select, boolean shouldTraverse) {
var streetVertex = intersectionVertex(1, 1);
var parking = VehicleParking
diff --git a/src/test/java/org/opentripplanner/street/search/state/StateDataTest.java b/src/test/java/org/opentripplanner/street/search/state/StateDataTest.java
index 1138fd6cf02..83cec24cd77 100644
--- a/src/test/java/org/opentripplanner/street/search/state/StateDataTest.java
+++ b/src/test/java/org/opentripplanner/street/search/state/StateDataTest.java
@@ -6,18 +6,20 @@
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.search.request.StreetSearchRequest;
-import org.opentripplanner.test.support.VariableSource;
class StateDataTest {
- static Stream cases = Arrays
- .stream(StreetMode.values())
- .flatMap(mode -> Stream.of(Arguments.of(true, mode), Arguments.of(false, mode)));
+ static Stream cases() {
+ return Arrays
+ .stream(StreetMode.values())
+ .flatMap(mode -> Stream.of(Arguments.of(true, mode), Arguments.of(false, mode)));
+ }
@ParameterizedTest(name = "arriveBy={0}, streetMode={1}")
- @VariableSource("cases")
+ @MethodSource("cases")
void baseCases(boolean arriveBy, StreetMode streetMode) {
var req = StreetSearchRequest.of().withArriveBy(arriveBy).withMode(streetMode).build();
var data = StateData.getBaseCaseStateData(req);
diff --git a/src/test/java/org/opentripplanner/street/search/state/StateTest.java b/src/test/java/org/opentripplanner/street/search/state/StateTest.java
index 34d3af11b68..9722f1dd785 100644
--- a/src/test/java/org/opentripplanner/street/search/state/StateTest.java
+++ b/src/test/java/org/opentripplanner/street/search/state/StateTest.java
@@ -31,11 +31,11 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.TraverseMode;
import org.opentripplanner.street.search.request.StreetSearchRequest;
-import org.opentripplanner.test.support.VariableSource;
class StateTest {
@@ -48,30 +48,32 @@ class StateTest {
NULL_RENTAL_STATES.add(null);
}
- static Stream testCases = Stream.of(
- of(SCOOTER_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
- //FIXME: it's strange that the arriveBy rental searches all start on a bicycle
- of(SCOOTER_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
- of(BIKE_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
- of(BIKE_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
- of(CAR_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
- of(CAR_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
- of(StreetMode.CAR, false, NULL_RENTAL_STATES, Set.of(CAR)),
- of(BIKE, false, NULL_RENTAL_STATES, Set.of(BICYCLE)),
- of(StreetMode.WALK, false, NULL_RENTAL_STATES, Set.of(TraverseMode.WALK)),
- of(BIKE_TO_PARK, false, NULL_RENTAL_STATES, Set.of(BICYCLE)),
- of(CAR_TO_PARK, false, NULL_RENTAL_STATES, Set.of(CAR)),
- of(FLEXIBLE, false, NULL_RENTAL_STATES, Set.of(WALK)),
- of(CAR_PICKUP, false, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
- of(CAR_PICKUP, true, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
- of(CAR_HAILING, false, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
- of(CAR_HAILING, true, NULL_RENTAL_STATES, Set.of(CAR, WALK))
- );
+ static Stream testCases() {
+ return Stream.of(
+ of(SCOOTER_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
+ //FIXME: it's strange that the arriveBy rental searches all start on a bicycle
+ of(SCOOTER_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
+ of(BIKE_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
+ of(BIKE_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
+ of(CAR_RENTAL, false, Set.of(BEFORE_RENTING), Set.of(WALK)),
+ of(CAR_RENTAL, true, Set.of(HAVE_RENTED, RENTING_FLOATING), Set.of(WALK, BICYCLE)),
+ of(StreetMode.CAR, false, NULL_RENTAL_STATES, Set.of(CAR)),
+ of(BIKE, false, NULL_RENTAL_STATES, Set.of(BICYCLE)),
+ of(StreetMode.WALK, false, NULL_RENTAL_STATES, Set.of(TraverseMode.WALK)),
+ of(BIKE_TO_PARK, false, NULL_RENTAL_STATES, Set.of(BICYCLE)),
+ of(CAR_TO_PARK, false, NULL_RENTAL_STATES, Set.of(CAR)),
+ of(FLEXIBLE, false, NULL_RENTAL_STATES, Set.of(WALK)),
+ of(CAR_PICKUP, false, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
+ of(CAR_PICKUP, true, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
+ of(CAR_HAILING, false, NULL_RENTAL_STATES, Set.of(CAR, WALK)),
+ of(CAR_HAILING, true, NULL_RENTAL_STATES, Set.of(CAR, WALK))
+ );
+ }
@ParameterizedTest(
name = "street mode {0}, arriveBy={1} should lead to initial states with rentalStates={2}, currentModes={3}"
)
- @VariableSource("testCases")
+ @MethodSource("testCases")
void initialStates(
StreetMode streetMode,
boolean arriveBy,
diff --git a/src/test/java/org/opentripplanner/test/support/VariableArgumentsProvider.java b/src/test/java/org/opentripplanner/test/support/VariableArgumentsProvider.java
deleted file mode 100644
index 1ae9fb2af84..00000000000
--- a/src/test/java/org/opentripplanner/test/support/VariableArgumentsProvider.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.opentripplanner.test.support;
-
-import java.lang.reflect.Field;
-import java.util.stream.Stream;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
-import org.junit.jupiter.params.support.AnnotationConsumer;
-
-/**
- * This annotation processor allows you to provide a variable as the input for a JUnit {@link
- * org.junit.jupiter.params.ParameterizedTest}.
- *
- * Check the usages of {@link VariableSource} to see examples for how to use.
- */
-class VariableArgumentsProvider implements ArgumentsProvider, AnnotationConsumer {
-
- private String variableName;
-
- @Override
- public Stream provideArguments(ExtensionContext context) {
- return context
- .getTestClass()
- .map(this::getField)
- .map(this::getValue)
- .orElseThrow(() -> new IllegalArgumentException("Failed to load test arguments"));
- }
-
- @Override
- public void accept(VariableSource variableSource) {
- variableName = variableSource.value();
- }
-
- private Field getField(Class clazz) {
- try {
- return clazz.getDeclaredField(variableName);
- } catch (Exception e) {
- return null;
- }
- }
-
- @SuppressWarnings("unchecked")
- private Stream getValue(Field field) {
- Object value = null;
- var accessible = field.isAccessible();
- try {
- field.setAccessible(true);
- value = field.get(null);
- } catch (Exception ignored) {}
-
- field.setAccessible(accessible);
-
- return value == null ? null : (Stream) value;
- }
-}
diff --git a/src/test/java/org/opentripplanner/test/support/VariableSource.java b/src/test/java/org/opentripplanner/test/support/VariableSource.java
deleted file mode 100644
index 254110cf6d2..00000000000
--- a/src/test/java/org/opentripplanner/test/support/VariableSource.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.opentripplanner.test.support;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import org.junit.jupiter.params.provider.ArgumentsSource;
-
-@Documented
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-@ArgumentsSource(VariableArgumentsProvider.class)
-public @interface VariableSource {
- /**
- * The name of the static variable
- */
- String value();
-}
diff --git a/src/test/java/org/opentripplanner/transit/model/framework/FeedScopedIdTest.java b/src/test/java/org/opentripplanner/transit/model/framework/FeedScopedIdTest.java
index 08df670ed62..a7c7c5ff058 100644
--- a/src/test/java/org/opentripplanner/transit/model/framework/FeedScopedIdTest.java
+++ b/src/test/java/org/opentripplanner/transit/model/framework/FeedScopedIdTest.java
@@ -3,13 +3,46 @@
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
class FeedScopedIdTest {
+ private static final List TRIMET_123 = List.of(new FeedScopedId("trimet", "123"));
+
@Test
void ofNullable() {
assertEquals(new FeedScopedId("FEED", "ID"), FeedScopedId.ofNullable("FEED", "ID"));
assertNull(FeedScopedId.ofNullable("FEED", null));
}
+
+ @ParameterizedTest
+ @ValueSource(
+ strings = { "trimet:123", "trimet:123 ", "trimet:123, ", ",trimet:123 , ", " trimet:123 " }
+ )
+ void parseList(String input) {
+ assertEquals(TRIMET_123, FeedScopedId.parseList(input));
+ }
+
+ @ParameterizedTest
+ @ValueSource(
+ strings = {
+ ",trimet:123 , ,\u200B,",
+ "\u200Btrimet:123",
+ "\u200B\u200Btri\u200Bmet:123\u200B",
+ "\ntrimet:123\t",
+ "\ntri\nmet:123\t",
+ }
+ )
+ void throwExceptionForInvisibleChar(String input) {
+ Assertions.assertThrows(
+ IllegalArgumentException.class,
+ () -> {
+ FeedScopedId.parseList(input);
+ }
+ );
+ }
}
diff --git a/src/test/java/org/opentripplanner/updater/trip/TimetableSnapshotSourceTest.java b/src/test/java/org/opentripplanner/updater/trip/TimetableSnapshotSourceTest.java
index d25de6ff021..8c28290de66 100644
--- a/src/test/java/org/opentripplanner/updater/trip/TimetableSnapshotSourceTest.java
+++ b/src/test/java/org/opentripplanner/updater/trip/TimetableSnapshotSourceTest.java
@@ -33,6 +33,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner.ConstantsForTests;
import org.opentripplanner.TestOtpModel;
import org.opentripplanner.framework.i18n.NonLocalizedString;
@@ -40,7 +41,6 @@
import org.opentripplanner.model.PickDrop;
import org.opentripplanner.model.Timetable;
import org.opentripplanner.model.TimetableSnapshot;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model.basic.TransitMode;
import org.opentripplanner.transit.model.framework.FeedScopedId;
import org.opentripplanner.transit.model.network.TripPattern;
@@ -1090,16 +1090,18 @@ SameAssert not() {
}
}
- static Stream purgeExpiredDataTestCases = Stream.of(
- // purgeExpiredData maxSnapshotFrequency || snapshots PatternSnapshotA PatternSnapshotB
- Arguments.of(Boolean.TRUE, -1, NotSame, NotSame),
- Arguments.of(Boolean.FALSE, -1, NotSame, Same),
- Arguments.of(Boolean.TRUE, 1000, NotSame, NotSame),
- Arguments.of(Boolean.FALSE, 1000, Same, Same)
- );
+ static Stream purgeExpiredDataTestCases() {
+ return Stream.of(
+ // purgeExpiredData maxSnapshotFrequency || snapshots PatternSnapshotA PatternSnapshotB
+ Arguments.of(Boolean.TRUE, -1, NotSame, NotSame),
+ Arguments.of(Boolean.FALSE, -1, NotSame, Same),
+ Arguments.of(Boolean.TRUE, 1000, NotSame, NotSame),
+ Arguments.of(Boolean.FALSE, 1000, Same, Same)
+ );
+ }
@ParameterizedTest(name = "purgeExpired: {0}, maxFrequency: {1} || {2} {3}")
- @VariableSource("purgeExpiredDataTestCases")
+ @MethodSource("purgeExpiredDataTestCases")
public void testPurgeExpiredData(
boolean purgeExpiredData,
int maxSnapshotFrequency,
diff --git a/src/test/java/org/opentripplanner/updater/vehicle_position/RealtimeVehicleMatcherTest.java b/src/test/java/org/opentripplanner/updater/vehicle_position/RealtimeVehicleMatcherTest.java
index 29d03844260..ea5d86cd0e1 100644
--- a/src/test/java/org/opentripplanner/updater/vehicle_position/RealtimeVehicleMatcherTest.java
+++ b/src/test/java/org/opentripplanner/updater/vehicle_position/RealtimeVehicleMatcherTest.java
@@ -23,12 +23,12 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opentripplanner._support.time.ZoneIds;
import org.opentripplanner.framework.geometry.WgsCoordinate;
import org.opentripplanner.model.StopTime;
import org.opentripplanner.service.realtimevehicles.internal.DefaultRealtimeVehicleService;
import org.opentripplanner.standalone.config.routerconfig.updaters.VehiclePositionsUpdaterConfig;
-import org.opentripplanner.test.support.VariableSource;
import org.opentripplanner.transit.model._data.TransitModelForTest;
import org.opentripplanner.transit.model.framework.Deduplicator;
import org.opentripplanner.transit.model.framework.FeedScopedId;
@@ -326,14 +326,16 @@ public void clearOldTrips() {
assertEquals(0, service.getRealtimeVehicles(pattern2).size());
}
- static Stream inferenceTestCases = Stream.of(
- Arguments.of("2022-04-05T15:26:04+02:00", "2022-04-05"),
- Arguments.of("2022-04-06T00:26:04+02:00", "2022-04-05"),
- Arguments.of("2022-04-06T10:26:04+02:00", "2022-04-06")
- );
+ static Stream inferenceTestCases() {
+ return Stream.of(
+ Arguments.of("2022-04-05T15:26:04+02:00", "2022-04-05"),
+ Arguments.of("2022-04-06T00:26:04+02:00", "2022-04-05"),
+ Arguments.of("2022-04-06T10:26:04+02:00", "2022-04-06")
+ );
+ }
@ParameterizedTest(name = "{0} should resolve to {1}")
- @VariableSource("inferenceTestCases")
+ @MethodSource("inferenceTestCases")
void inferServiceDayOfTripAt6(String time, String expectedDate) {
var trip = TransitModelForTest.trip(tripId).build();
diff --git a/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan-extended.json b/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan-extended.json
index 557cdec8659..ea58480be8e 100644
--- a/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan-extended.json
+++ b/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan-extended.json
@@ -3,6 +3,8 @@
"plan" : {
"itineraries" : [
{
+ "start" : "2020-02-02T11:00:00Z",
+ "end" : "2020-02-02T12:00:00Z",
"startTime" : 1580641200000,
"endTime" : 1580644800000,
"generalizedCost" : 4072,
@@ -16,10 +18,26 @@
"legs" : [
{
"mode" : "WALK",
+ "start" : {
+ "scheduledTime" : "2020-02-02T11:00:00Z",
+ "estimated" : null
+ },
+ "end" : {
+ "scheduledTime" : "2020-02-02T11:00:20Z",
+ "estimated" : null
+ },
"from" : {
"name" : "A",
"lat" : 5.0,
"lon" : 8.0,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:00:00Z",
+ "estimated" : null
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:00:00Z",
+ "estimated" : null
+ },
"departureTime" : 1580641200000,
"arrivalTime" : 1580641200000
},
@@ -27,6 +45,14 @@
"name" : "B",
"lat" : 6.0,
"lon" : 8.5,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:00:20Z",
+ "estimated" : null
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:00:20Z",
+ "estimated" : null
+ },
"departureTime" : 1580641220000,
"arrivalTime" : 1580641220000
},
@@ -35,16 +61,45 @@
"generalizedCost" : 40,
"headsign" : null,
"trip" : null,
+ "intermediatePlaces" : null,
"alerts" : [ ],
"rideHailingEstimate" : null,
"accessibilityScore" : null
},
{
"mode" : "BUS",
+ "start" : {
+ "scheduledTime" : "2020-02-02T10:51:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:01:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "end" : {
+ "scheduledTime" : "2020-02-02T11:05:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:15:00Z",
+ "delay" : "PT10M"
+ }
+ },
"from" : {
"name" : "B",
"lat" : 6.0,
"lon" : 8.5,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T10:51:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:01:00Z"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T10:51:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:01:00Z"
+ }
+ },
"departureTime" : 1580641260000,
"arrivalTime" : 1580641260000
},
@@ -52,6 +107,20 @@
"name" : "C",
"lat" : 7.0,
"lon" : 9.0,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:05:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:15:00Z"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:05:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:15:00Z"
+ }
+ },
"departureTime" : 1580642100000,
"arrivalTime" : 1580642100000
},
@@ -62,16 +131,65 @@
"trip" : {
"tripHeadsign" : "Trip headsign 122"
},
+ "intermediatePlaces" : [
+ {
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:01:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:11:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:01:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:11:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "stop" : {
+ "name" : "B"
+ }
+ }
+ ],
"alerts" : [ ],
"rideHailingEstimate" : null,
"accessibilityScore" : null
},
{
"mode" : "RAIL",
+ "start" : {
+ "scheduledTime" : "2020-02-02T11:20:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:30:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "end" : {
+ "scheduledTime" : "2020-02-02T11:40:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:50:00Z",
+ "delay" : "PT10M"
+ }
+ },
"from" : {
"name" : "C",
"lat" : 7.0,
"lon" : 9.0,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:20:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:30:00Z"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:20:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:30:00Z"
+ }
+ },
"departureTime" : 1580643000000,
"arrivalTime" : 1580643000000
},
@@ -79,6 +197,20 @@
"name" : "D",
"lat" : 8.0,
"lon" : 9.5,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:40:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:50:00Z"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:40:00Z",
+ "estimated" : {
+ "delay" : "PT10M",
+ "time" : "2020-02-02T11:50:00Z"
+ }
+ },
"departureTime" : 1580644200000,
"arrivalTime" : 1580644200000
},
@@ -89,6 +221,27 @@
"trip" : {
"tripHeadsign" : "Trip headsign 439"
},
+ "intermediatePlaces" : [
+ {
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:30:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:40:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:30:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:40:00Z",
+ "delay" : "PT10M"
+ }
+ },
+ "stop" : {
+ "name" : "C"
+ }
+ }
+ ],
"alerts" : [
{
"id" : "QWxlcnQ6Rjphbi1hbGVydA",
@@ -115,10 +268,26 @@
},
{
"mode" : "CAR",
+ "start" : {
+ "scheduledTime" : "2020-02-02T11:50:00Z",
+ "estimated" : null
+ },
+ "end" : {
+ "scheduledTime" : "2020-02-02T12:00:00Z",
+ "estimated" : null
+ },
"from" : {
"name" : "D",
"lat" : 8.0,
"lon" : 9.5,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:50:00Z",
+ "estimated" : null
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:50:00Z",
+ "estimated" : null
+ },
"departureTime" : 1580644200000,
"arrivalTime" : 1580644200000
},
@@ -126,6 +295,14 @@
"name" : "E",
"lat" : 9.0,
"lon" : 10.0,
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T12:00:00Z",
+ "estimated" : null
+ },
+ "departure" : {
+ "scheduledTime" : "2020-02-02T12:00:00Z",
+ "estimated" : null
+ },
"departureTime" : 1580644800000,
"arrivalTime" : 1580644800000
},
@@ -134,6 +311,7 @@
"generalizedCost" : 1000,
"headsign" : null,
"trip" : null,
+ "intermediatePlaces" : null,
"alerts" : [ ],
"rideHailingEstimate" : {
"provider" : {
diff --git a/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan.json b/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan.json
index 06fd20be150..d213443f7cd 100644
--- a/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan.json
+++ b/src/test/resources/org/opentripplanner/apis/gtfs/expectations/plan.json
@@ -3,47 +3,57 @@
"plan" : {
"itineraries" : [
{
- "startTime" : 1580641200000,
- "endTime" : 1580644800000,
+ "start" : "2020-02-02T11:00:00Z",
+ "end" : "2020-02-02T12:00:00Z",
"legs" : [
{
"mode" : "WALK",
- "startTime" : 1580641200000,
- "endTime" : 1580641220000,
"from" : {
"name" : "A",
"lat" : 5.0,
"lon" : 8.0,
- "departureTime" : 1580641200000,
- "arrivalTime" : 1580641200000
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:00:00Z",
+ "estimated" : null
+ }
},
"to" : {
"name" : "B",
"lat" : 6.0,
"lon" : 8.5,
- "departureTime" : 1580641220000,
- "arrivalTime" : 1580641220000
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:00:20Z",
+ "estimated" : null
+ }
},
"route" : null,
"legGeometry" : null
},
{
"mode" : "BUS",
- "startTime" : 1580641260000,
- "endTime" : 1580642100000,
"from" : {
"name" : "B",
"lat" : 6.0,
"lon" : 8.5,
- "departureTime" : 1580641260000,
- "arrivalTime" : 1580641260000
+ "departure" : {
+ "scheduledTime" : "2020-02-02T10:51:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:01:00Z",
+ "delay" : "PT10M"
+ }
+ }
},
"to" : {
"name" : "C",
"lat" : 7.0,
"lon" : 9.0,
- "departureTime" : 1580642100000,
- "arrivalTime" : 1580642100000
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:05:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:15:00Z",
+ "delay" : "PT10M"
+ }
+ }
},
"route" : {
"gtfsId" : "F:BUS",
@@ -56,21 +66,29 @@
},
{
"mode" : "RAIL",
- "startTime" : 1580643000000,
- "endTime" : 1580644200000,
"from" : {
"name" : "C",
"lat" : 7.0,
"lon" : 9.0,
- "departureTime" : 1580643000000,
- "arrivalTime" : 1580643000000
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:20:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:30:00Z",
+ "delay" : "PT10M"
+ }
+ }
},
"to" : {
"name" : "D",
"lat" : 8.0,
"lon" : 9.5,
- "departureTime" : 1580644200000,
- "arrivalTime" : 1580644200000
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T11:40:00Z",
+ "estimated" : {
+ "time" : "2020-02-02T11:50:00Z",
+ "delay" : "PT10M"
+ }
+ }
},
"route" : {
"gtfsId" : "F:2",
@@ -83,21 +101,23 @@
},
{
"mode" : "CAR",
- "startTime" : 1580644200000,
- "endTime" : 1580644800000,
"from" : {
"name" : "D",
"lat" : 8.0,
"lon" : 9.5,
- "departureTime" : 1580644200000,
- "arrivalTime" : 1580644200000
+ "departure" : {
+ "scheduledTime" : "2020-02-02T11:50:00Z",
+ "estimated" : null
+ }
},
"to" : {
"name" : "E",
"lat" : 9.0,
"lon" : 10.0,
- "departureTime" : 1580644800000,
- "arrivalTime" : 1580644800000
+ "arrival" : {
+ "scheduledTime" : "2020-02-02T12:00:00Z",
+ "estimated" : null
+ }
},
"route" : null,
"legGeometry" : null
diff --git a/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan-extended.graphql b/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan-extended.graphql
index db30d8489ef..bcd96892e84 100644
--- a/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan-extended.graphql
+++ b/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan-extended.graphql
@@ -16,6 +16,9 @@
}
]) {
itineraries {
+ start
+ end
+ # next two are deprecated
startTime
endTime
generalizedCost
@@ -28,10 +31,38 @@
walkTime
legs {
mode
+ start {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
+ end {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
from {
name
lat
lon
+ arrival {
+ scheduledTime
+ estimated {
+ delay
+ time
+ }
+ }
+ departure {
+ scheduledTime
+ estimated {
+ delay
+ time
+ }
+ }
departureTime
arrivalTime
}
@@ -39,6 +70,20 @@
name
lat
lon
+ arrival {
+ scheduledTime
+ estimated {
+ delay
+ time
+ }
+ }
+ departure {
+ scheduledTime
+ estimated {
+ delay
+ time
+ }
+ }
departureTime
arrivalTime
}
@@ -50,6 +95,25 @@
trip {
tripHeadsign
}
+ intermediatePlaces {
+ arrival {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
+ departure {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
+ stop {
+ name
+ }
+ }
alerts {
id
alertHeaderText
diff --git a/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan.graphql b/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan.graphql
index d71c991234d..39877eef0b7 100644
--- a/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan.graphql
+++ b/src/test/resources/org/opentripplanner/apis/gtfs/queries/plan.graphql
@@ -17,25 +17,33 @@
},
]) {
itineraries {
- startTime
- endTime
+ start
+ end
legs {
mode
- startTime
- endTime
from {
name
lat
lon
- departureTime
- arrivalTime
+ departure {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
}
to {
name
lat
lon
- departureTime
- arrivalTime
+ arrival {
+ scheduledTime
+ estimated {
+ time
+ delay
+ }
+ }
}
route {
gtfsId