How to use

build

method

in

com.github.rinde.rinsim.scenario.Scenario$Builder

 @Nonnull
 @Override
 public Scenario apply(@Nullable Scenario input) {
  final Scenario in = verifyNotNull(input);
  return Scenario.builder(in)
   .clearEvents()
   .addEvents(
    FluentIterable.from(in.getEvents()).transform(converter))
   .build();
 }
};

 @Nonnull
 @Override
 public Scenario apply(@Nullable Scenario input) {
  final Scenario in = verifyNotNull(input);
  return Scenario.builder(in)
   .clearEvents()
   .addEvents(
    FluentIterable.from(in.getEvents()).transform(converter))
   .build();
 }
};

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

/**
 * 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 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));
}

@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();
}

@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();
}

/**
 * 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());
}

/**
 * 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 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);
}

@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 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));
}

@Test
public void testPDPCollisionGraphRoadModel() {
 final Scenario.Builder sb = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS);
 sb.addModel(
  PDPCollisionGraphRoadModel.builderForCollisionGraphRm(
   RoadModelBuilders.dynamicGraph(
    ListenableGraph.supplier(
     DotGraphIO.getLengthDataGraphSupplier("fake.path")))
    .withCollisionAvoidance()));
 ScenarioTestUtil.assertScenarioIO(sb.build());
}

@Test
public void testPDPGraphRoadModel() {
 final Scenario.Builder sb = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS);
 sb.addModel(PDPGraphRoadModel.builderForGraphRm(
  RoadModelBuilders.staticGraph(
   DotGraphIO.getLengthDataGraphSupplier("fake.path"))));
 ScenarioTestUtil.assertScenarioIO(sb.build());
}

@Test
public void testPDPRoadModel() {
 final Scenario.Builder sb = Scenario
  .builder(Scenario.DEFAULT_PROBLEM_CLASS);
 sb.addModel(PDPRoadModel.builder(RoadModelBuilders.plane()));
 ScenarioTestUtil.assertScenarioIO(sb.build());
}

@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());
}

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