How to use

Scenario$Builder

in

com.github.rinde.rinsim.scenario

 @Override
 @Nullable
 public Scenario apply(@Nullable Scenario input) {
  return Scenario.builder(verifyNotNull(input))
   .removeModelsOfType(TimeModel.AbstractBuilder.class)
   .addModel(timeModel)
   .build();
 }
};

/**
 * Sets up a scenario.
 */
@Before
public void setUp() {
 scenario = Scenario
  .builder()
  .addEvent(EventC.create(100))
  .addEvent(EventA.create(0))
  .addEvent(EventA.create(1))
  .addEvent(EventB.create(0))
  .addEvent(EventB.create(0))
  .addEvent(EventC.create(5))
  .build();
 assertThat(scenario).isNotNull();
 TestUtil.testEnum(ScenarioController.EventType.class);
 final ClockController clock = mock(ClockController.class);
 when(clock.getEventAPI()).thenReturn(mock(EventAPI.class));
 final SimulatorAPI sim = mock(SimulatorAPI.class);
 dependencyProvider = mock(DependencyProvider.class);
 when(dependencyProvider.get(ClockController.class)).thenReturn(clock);
 when(dependencyProvider.get(Clock.class)).thenReturn(clock);
 when(dependencyProvider.get(SimulatorAPI.class)).thenReturn(sim);
}

/**
 * Tests whether events are sorted by time.
 */
@Test
public void testSorting() {
 final List<TimedEvent> events = new ArrayList<>(10);
 final AddObjectEvent A1 = AddObjectEvent.create(0, new Point(1, 0));
 final AddObjectEvent A2 = AddObjectEvent.create(0, new Point(2, 0));
 final AddObjectEvent B = AddObjectEvent.create(1, new Point(1, 1));
 final AddObjectEvent C = AddObjectEvent.create(2, new Point(1, 0));
 final AddObjectEvent D1 = AddObjectEvent.create(3, new Point(1, 2));
 final AddObjectEvent D2 = AddObjectEvent.create(3, new Point(1, 3));
 final AddObjectEvent E = AddObjectEvent.create(4, new Point(2, 0));
 final AddObjectEvent F = AddObjectEvent.create(5, new Point(4, 0));
 events.addAll(asList(A1, A2, B, C, D1, D2, E, F));
 Collections.reverse(events);
 final Scenario s = Scenario.builder().addEvents(events).build();
 final List<TimedEvent> res = newArrayList(s.getEvents());
 assertEquals(asList(A2, A1, B, C, D2, D1, E, F), res);
 assertFalse(res.equals(events));
 assertEquals(events.size(), res.size());
}

/**
 * Tests that the {@link PDPRoadModel} supports serialization and
 * deserialization.
 */
@Test
public void testIO() {
 final Scenario.Builder sb = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS)
  .addModel(PDPRoadModel.builder(
   RoadModelBuilders.plane()
    .withSpeedUnit(NonSI.MILES_PER_HOUR)
    .withMaxSpeed(7))
   .withAllowVehicleDiversion(true));
 final Scenario s = sb.problemClass(TestProblemClass.TEST).build();
 ScenarioTestUtil.assertScenarioIO(s);
}

/**
 * Test correct ordering of events.
 */
@Test
public void testAddEvents() {
 final TimedEvent ev0 = EventA.create(0);
 final TimedEvent ev1 = EventB.create(205);
 final TimedEvent ev2 = EventB.create(7);
 final TimedEvent ev3 = EventB.create(203);
 final Scenario scenario = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS)
  .addEvent(ev0)
  .addEvent(ev1)
  .addEvents(asList(ev2, ev3))
  .build();
 assertEquals(asList(ev0, ev2, ev3, ev1), scenario.getEvents());
}

@Override
@Nullable
public Scenario apply(@Nullable Scenario input) {
 final Scenario in = verifyNotNull(input);
 final Optional<TimeModel.AbstractBuilder<?>> timeModel =
  getTimeModel(in);
 RealtimeBuilder rtb = TimeModel.builder()
  .withRealTime()
  .withStartInClockMode(ClockMode.SIMULATED);
 if (timeModel.isPresent()) {
  // copy properties from existing time model
  rtb = rtb.withTickLength(timeModel.get().getTickLength())
   .withTimeUnit(timeModel.get().getTimeUnit());
 }
 // else: in this case we don't copy properties, we use the defaults
 return Scenario.builder(in)
  .removeModelsOfType(TimeModel.AbstractBuilder.class)
  .addModel(rtb)
  .build();
}

/**
 * Test equals method with differing events.
 */
@Test
public void testEqualsEvents() {
 final List<EventA> events1 = asList(EventA.create(0));
 final List<EventA> events2 = asList(EventA.create(0));
 final List<EventA> events3 = asList(EventA.create(1));
 final List<EventA> events4 = asList(EventA.create(1), EventA.create(2));
 final Scenario s1 = Scenario.builder().addEvents(events1).build();
 final Scenario s2 = Scenario.builder().addEvents(events2).build();
 final Scenario s3 = Scenario.builder().addEvents(events3).build();
 final Scenario s4 = Scenario.builder().addEvents(events4).build();
 assertNotEquals(s1, new Object());
 assertEquals(s1, s2);
 assertNotEquals(s1, s3);
 assertNotEquals(s1, s4);
}

@Nullable
@Override
public Scenario apply(@Nullable Scenario input) {
 final Scenario in = verifyNotNull(input);
 final Optional<TimeModel.AbstractBuilder<?>> timeModel =
  getTimeModel(in);
 final TimeModel.Builder rtb = TimeModel.builder();
 if (timeModel.isPresent()) {
  rtb.withTickLength(timeModel.get().getTickLength())
   .withTimeUnit(timeModel.get().getTimeUnit());
 }
 return Scenario.builder(in)
  .removeModelsOfType(TimeModel.AbstractBuilder.class)
  .addModel(rtb)
  .build();
}

 /**
  * Tests that IAE is thrown when there are too many time models.
  */
 @Test
 public void testTooManyTimeModels() {
  final Scenario s = Scenario.builder()
   .addModel(TimeModel.builder())
   .addModel(TimeModel.builder().withRealTime())
   .build();
  boolean fail = false;
  try {
   ScenarioConverters.toRealtime().apply(s);
  } catch (final IllegalArgumentException e) {
   fail = true;
   assertThat(e.getMessage())
    .isEqualTo("More than one time model is not supported.");
  }
  assertThat(fail).isTrue();
 }
}

/**
 * Tests that when a time model already exists, its properties are copied.
 */
@Test
public void testCopyProperties() {
 final Scenario s = Scenario.builder()
  .addModel(TimeModel.builder()
   .withTickLength(754L)
   .withTimeUnit(NonSI.DAY))
  .addModel(CommModel.builder())
  .build();
 final Scenario converted =
  verifyNotNull(ScenarioConverters.toRealtime().apply(s));
 assertThat(converted.getModelBuilders())
  .contains(TimeModel.builder()
   .withRealTime()
   .withStartInClockMode(ClockMode.SIMULATED)
   .withTickLength(754L)
   .withTimeUnit(NonSI.DAY));
}

/**
 * Test the default settings of a scenario.
 */
@Test
public void testDefaults() {
 final Scenario.Builder builder = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS);
 assertThat(builder.getTimeWindow())
  .isEqualTo(TimeWindow.create(0, 8 * 60 * 60 * 1000));
 assertThat(builder.getStopCondition())
  .isEqualTo(StopConditions.alwaysFalse());
 final Scenario scenario = builder.build();
 assertTrue(scenario.getModelBuilders().isEmpty());
 assertSame(Scenario.DEFAULT_PROBLEM_CLASS, scenario.getProblemClass());
 assertEquals("", scenario.getProblemInstanceId());
 assertThat(scenario.getStopCondition()).isEqualTo(
  StopConditions.alwaysFalse());
 assertEquals(TimeWindow.create(0, 8 * 60 * 60 * 1000),
  scenario.getTimeWindow());
}

/**
 * Tests the removal of model builders.
 */
@Test
public void testRemoveModelsOfType() {
 final Scenario.Builder builder = Scenario.builder();
 builder.addModel(TimeModel.builder())
  .addModel(TimeModel.builder().withRealTime())
  .addModel(RoadModelBuilders.plane())
  .addModel(CommModel.builder());
 assertThat(builder.modelBuilders).hasSize(4);
 builder.removeModelsOfType(RoadModelBuilders.PlaneRMB.class);
 assertThat(builder.modelBuilders).hasSize(3);
 assertThat(builder.modelBuilders).containsExactly(TimeModel.builder(),
  TimeModel.builder().withRealTime(), CommModel.builder());
 builder.removeModelsOfType(RoadModelBuilders.AbstractGraphRMB.class);
 builder.removeModelsOfType(TimeModel.AbstractBuilder.class);
 assertThat(builder.modelBuilders).hasSize(1);
 assertThat(builder.modelBuilders).containsExactly(CommModel.builder());
 builder.removeModelsOfType(CommModel.Builder.class);
 assertThat(builder.modelBuilders).isEmpty();
}

/**
 * Test copying by builder.
 */
@Test
public void testCreateScenarioByCopying() {
 final Scenario s = Scenario.builder()
  .addEvent(AddObjectEvent.create(100, new Point(0, 0)))
  .addEvent(AddObjectEvent.create(200, new Point(0, 0)))
  .addEvent(AddObjectEvent.create(300, new Point(0, 0)))
  .build();
 assertEquals(3, s.getEvents().size());
 final Scenario s2 = Scenario.builder(s).build();
 assertEquals(3, s.getEvents().size());
 assertEquals(3, s2.getEvents().size());
}

/**
 * Tests {@link ScenarioIO#readerAdapter(com.google.common.base.Function)}.
 * @throws IOException When IO fails.
 */
@Test
public void testReaderAdapter() throws IOException {
 final Scenario s = Scenario.builder()
  .addModel(TimeModel.builder().withTickLength(7L))
  .build();
 final Path tmpDir = Files.createTempDirectory("rinsim-scenario-io-test");
 final Path file = Paths.get(tmpDir.toString(), "test.scen");
 ScenarioIO.write(s, file);
 final Scenario out = ScenarioIO.reader().apply(file);
 final Scenario convertedOut =
  verifyNotNull(ScenarioIO.readerAdapter(ScenarioConverters.toRealtime())
   .apply(file));
 assertThat(s).isEqualTo(out);
 assertThat(s).isNotEqualTo(convertedOut);
 assertThat(convertedOut.getModelBuilders())
  .contains(TimeModel.builder()
   .withRealTime()
   .withStartInClockMode(ClockMode.SIMULATED)
   .withTickLength(7L));
 Files.delete(file);
 Files.delete(tmpDir);
}

@Nullable
@Override
public Scenario apply(@Nullable Scenario input) {
 final Scenario in = verifyNotNull(input);
 final Optional<TimeModel.AbstractBuilder<?>> timeModel =
  getTimeModel(in);
 final TimeModel.Builder rtb = TimeModel.builder();
 if (timeModel.isPresent()) {
  rtb.withTickLength(timeModel.get().getTickLength())
   .withTimeUnit(timeModel.get().getTimeUnit());
 }
 return Scenario.builder(in)
  .removeModelsOfType(TimeModel.AbstractBuilder.class)
  .addModel(rtb)
  .build();
}

.removeModelsOfType(TimeModel.AbstractBuilder.class)
.addModel(TimeModel.builder()
 .withRealTime()
 .withStartInClockMode(ClockMode.SIMULATED))
.clearEvents()
.addEvents(events)
.addEvent(TimeOutEvent.create(3 * 60 * 60 * 1000))
.build();

/**
 * Tests that when no time model is available, a default is added.
 */
@Test
public void testEmpty() {
 final Scenario empty = Scenario.builder().build();
 assertThat(empty.getModelBuilders()).isEmpty();
 final Scenario convertedEmpty =
  verifyNotNull(ScenarioConverters.toRealtime().apply(empty));
 assertThat(convertedEmpty.getModelBuilders())
  .contains(TimeModel.builder()
   .withRealTime()
   .withStartInClockMode(ClockMode.SIMULATED));
}

 /**
  * Tests detection and correct error message.
  * @throws IOException If something goes wrong with the filesystem.
  */
 @Test
 public void testGraphRmbDirectIO() throws IOException {
  final Graph<LengthData> g = new TableGraph<>();
  g.addConnection(new Point(0, 0), new Point(1, 0));
  g.addConnection(new Point(1, 1), new Point(1, 0));

  final Scenario s = Scenario.builder()
   .addModel(TimeModel.builder().withTickLength(7L))
   .addModel(RoadModelBuilders.staticGraph(Suppliers.ofInstance(g)))
   .build();

  boolean fail = false;
  try {
   ScenarioIO.write(s);
  } catch (final IllegalArgumentException e) {
   fail = true;
   assertThat(e.getMessage())
    .isEqualTo("A graph cannot be serialized embedded in a scenario.");
  }
  assertThat(fail).isTrue();
 }
}

/**
 * Add the specified {@link TimedEvent}s to the builder.
 * @param events The events to add.
 * @return This, as per the builder pattern.
 */
public Builder addEvents(Iterable<? extends TimedEvent> events) {
 for (final TimedEvent te : events) {
  addEvent(te);
 }
 return self();
}

static Scenario createScenario(long... delays) {
 final long endTime = 15 * 60 * 1000;
 final VehicleDTO vehicle = VehicleDTO.builder()
  .startPosition(new Point(5, 5))
  .availabilityTimeWindow(TimeWindow.create(0, endTime))
  .build();
 final Scenario.Builder scenario = Scenario.builder()
  .addEvent(AddDepotEvent.create(-1, new Point(5, 5)))
  .addEvent(AddVehicleEvent.create(-1, vehicle))
  .addEvent(AddVehicleEvent.create(-1, vehicle))
  .addEvent(TimeOutEvent.create(endTime))
  .addModel(PDPRoadModel.builder(RoadModelBuilders.plane())
   .withAllowVehicleDiversion(true))
  .addModel(DefaultPDPModel.builder())
  .addModel(TimeModel.builder().withTickLength(250))
  .setStopCondition(StopConditions.and(
   StatsStopConditions.vehiclesDoneAndBackAtDepot(),
   StatsStopConditions.timeOutEvent()));
 final long[] dls = new long[3];
 System.arraycopy(delays, 0, dls, 0, delays.length);
 scenario
  .addEvent(createParcel(0, dls[0], new Point(1, 1), new Point(9, 1)));
 scenario
  .addEvent(createParcel(1, dls[1], new Point(1, 2), new Point(9, 2)));
 scenario
  .addEvent(createParcel(2, dls[2], new Point(9, 9), new Point(1, 9)));
 return scenario.build();
}