@Override public ImmutableSet<ModelBuilder<?, ?>> getModelBuilders() { return ImmutableSet.<ModelBuilder<?, ?>>builder() .add( TimeModel.builder() .withTickLength(1L) .withTimeUnit(NonSI.MINUTE)) .add( RoadModelBuilders.plane() .withMinPoint(getMin()) .withMaxPoint(getMax()) .withDistanceUnit(SI.KILOMETER) .withMaxSpeed(MAX_SPEED) .withSpeedUnit( SI.KILOMETRE.divide(NonSI.MINUTE).asType(Velocity.class))) .add( DefaultPDPModel.builder() .withTimeWindowPolicy(TimeWindowPolicies.TARDY_ALLOWED)) .add( StatsTracker.builder()) .build(); }
TestUtil.testPrivateConstructor(RoadModelBuilders.class); final PlaneRMB plane = plane(); final StaticGraphRMB stat = staticGraph(new TableGraph<>()); final DynamicGraphRMB dynamic = dynamicGraph(new ListenableGraph<>( new TableGraph<>())); final CollisionGraphRMB coll = dynamicGraph( new ListenableGraph<>(new TableGraph<>())) .withCollisionAvoidance(); final CachedGraphRMB cach = staticGraph(new TableGraph<>()) .withCache(); plane().withMaxPoint(new Point(7, 7))); assertThat(stat).isEqualTo( staticGraph(new MultimapGraph<>())); assertThat(plane).isEqualTo(RoadModelBuilders.plane()); assertThat(plane).isNotEqualTo( RoadModelBuilders.plane().withDistanceUnit(SI.CENTIMETER)); dynamicGraph(new ListenableGraph<>(new TableGraph<>())) .withCollisionAvoidance() .withVehicleLength(7d)); assertThat(coll).isNotEqualTo( dynamicGraph(new ListenableGraph<>(new TableGraph<>())) .withCollisionAvoidance() .withDistanceUnit(NonSI.YARD));
@Parameters public static Collection<Object[]> configs() { // Graph should be constructed before model, // since GraphRoadModelSnapshot should be consistent // with the actual graph in a static case. final ImmutableMultimap graphAsMap = ImmutableMultimap.builder().put(SW, SE).put(SE, NE).put(NE, NW).build(); final Table<Point, Point, Connection<LengthData>> graphAsTable = HashBasedTable.create(); graphAsTable.put(SW, SE, Connection.create(SW, SE, LengthData.create(10))); graphAsTable.put(SE, NE, Connection.create(SE, NE, LengthData.create(10))); graphAsTable.put(NE, NW, Connection.create(NE, NW, LengthData.create(10))); return Arrays.asList(new Object[][] { {RoadModelBuilders.staticGraph(MultimapGraph.supplier(graphAsMap))}, {RoadModelBuilders.staticGraph(MultimapGraph.supplier(graphAsMap)) .withCache()}, {RoadModelBuilders .staticGraph(TableGraph.<LengthData>supplier(ImmutableTable .<Point, Point, Connection<LengthData>>copyOf(graphAsTable)))}, {RoadModelBuilders .staticGraph(TableGraph.supplier(ImmutableTable .<Point, Point, Connection<LengthData>>copyOf(graphAsTable))) .withCache()}, {RoadModelBuilders.dynamicGraph(ListenableGraph .supplier(TableGraph.supplier(ImmutableTable .<Point, Point, Connection<LengthData>>copyOf(graphAsTable))))} }); }
/** * Create a {@link RoadModelBuilders.DynamicGraphRMB} for constructing * {@link DynamicGraphRoadModel} instances. * @param g A {@link ListenableGraph}. * @return A new {@link RoadModelBuilders.DynamicGraphRMB} instance. */ public static RoadModelBuilders.DynamicGraphRMB dynamicGraph( ListenableGraph<?> g) { return dynamicGraph(Suppliers.<ListenableGraph<?>>ofInstance(g)); }
public BrokenRoadModel(Graph<? extends ConnectionData> pGraph) { super(pGraph, RoadModelBuilders.staticGraph(pGraph)); }
RoadModelBuilders.staticGraph(g) .withDistanceUnit(SI.KILOMETER) .withSpeedUnit(NonSI.KILOMETERS_PER_HOUR)) } else { rm = PDPRoadModel.builder( RoadModelBuilders.plane() .withMinPoint(new Point(0, 0)) .withMaxPoint(new Point(10, 10))
.builder() .setRandomGenerator(rng) .addModel(RoadModelBuilders.dynamicGraph(new ListenableGraph<>(g)) .withDistanceUnit(SI.METER) .withSpeedUnit(NonSI.KILOMETERS_PER_HOUR)
@Override public GenericRoadModel create(ForwardingRoadModelTest testClass) { return new ForwardingRoadModel(RoadModelBuilders.staticGraph(testClass .createGraph()).build(mock(DependencyProvider.class))); } }}, {new Creator() {
.add( PDPRoadModel.builder( RoadModelBuilders.plane() .withMinPoint(MIN) .withMaxPoint(MAX)
.builder() .setRandomGenerator(rng) .addModel(RoadModelBuilders.dynamicGraph(new ListenableGraph<>(g)) .withDistanceUnit(SI.METER) .withSpeedUnit(NonSI.KILOMETERS_PER_HOUR)
@Parameters public static Collection<Object[]> configs() { final double five = 5; final double twoAndHalf = 2.5; return Arrays .asList(new Object[][] { {RoadModelBuilders.staticGraph(MultimapGraph.supplier()), five}, {RoadModelBuilders.staticGraph(MultimapGraph.supplier()) .withCache(), five}, {RoadModelBuilders.staticGraph(MultimapGraph.supplier()), twoAndHalf}, {RoadModelBuilders.staticGraph(MultimapGraph.supplier()) .withCache(), twoAndHalf}, {RoadModelBuilders.staticGraph(TableGraph.supplier()), five}, {RoadModelBuilders.staticGraph(TableGraph.supplier()).withCache(), five}, {RoadModelBuilders.staticGraph(TableGraph.supplier()), twoAndHalf}, {RoadModelBuilders.staticGraph(TableGraph.supplier()).withCache(), twoAndHalf} }); }
/** * Test for illegal max speed. */ @Test public void builderIllegalMaxSpeed() { boolean fail = false; try { RoadModelBuilders.plane() .withMaxSpeed(0d) .build(mock(DependencyProvider.class)); } catch (final IllegalArgumentException e) { fail = true; } assertTrue(fail); }
try { @SuppressWarnings("unused") final CollisionGraphRMB b = RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withVehicleLength(0d); try { @SuppressWarnings("unused") final CollisionGraphRMB b = RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withVehicleLength(Double.POSITIVE_INFINITY); final CollisionGraphRoadModel cgr1 = RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withDistanceUnit(SI.METER)
/** * Tests that unregistering a model is not possible. */ @Test(expected = IllegalArgumentException.class) public void unregisterFailModel() { emptyManager.unregister(RoadModelBuilders.staticGraph( new MultimapGraph<LengthData>()).build(mock(DependencyProvider.class))); }
/** * Tests that units are correctly set. */ @Test public void testAbstractRMBUnits() { final PlaneRoadModel prm = RoadModelBuilders.plane() .withDistanceUnit(NonSI.LIGHT_YEAR) .withSpeedUnit(NonSI.C) .build(mock(DependencyProvider.class)); assertThat(prm.getDistanceUnit()).isEqualTo(NonSI.LIGHT_YEAR); assertThat(prm.getSpeedUnit()).isEqualTo(NonSI.C); }
assertEquals(0d, RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withMinDistance(0d) 0); assertEquals(2d, RoadModelBuilders.dynamicGraph(graph) .withDistanceUnit(SI.METER) .withCollisionAvoidance() RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withVehicleLength(1d) try { @SuppressWarnings("unused") final CollisionGraphRMB b = RoadModelBuilders.dynamicGraph(graph) .withCollisionAvoidance() .withMinDistance(-1d);
/** * A model can not be registered. */ @Test(expected = IllegalArgumentException.class) public void canNotRegisterModel() { emptyManager.register(RoadModelBuilders.staticGraph( new MultimapGraph<LengthData>()).build(mock(DependencyProvider.class))); }
@Override public void doSetUp() { model = RoadModelBuilders.plane() .withMinPoint(new Point(0, 0)) .withMaxPoint(new Point(10, 10)) .withMaxSpeed(10d) .build(mock(DependencyProvider.class)); }
@Test public void testPDPDynamicGraphRoadModel() { final Scenario.Builder sb = Scenario .builder(Scenario.DEFAULT_PROBLEM_CLASS); sb.addModel( PDPDynamicGraphRoadModel.builderForDynamicGraphRm( RoadModelBuilders.dynamicGraph( ListenableGraph.supplier( DotGraphIO.getLengthDataGraphSupplier("fake.path"))))); ScenarioTestUtil.assertScenarioIO(sb.build()); }
@Test(expected = RuntimeException.class) public void impossiblePath() throws InstantiationException, IllegalAccessException { final Graph<?> gg = rmType.newInstance(); final GraphRoadModel roads = RoadModelBuilders.staticGraph(gg).build( mock(DependencyProvider.class)); gg.addConnection(a, b); gg.addConnection(b, c); Graphs.shortestPathEuclideanDistance(roads.getGraph(), b, a); }