@Override @Nonnull public <U> U get(Class<U> clazz) { if (clazz == RealtimeClockController.class) { return clazz.cast(this); } return super.get(clazz); }
/** * Tests that time lapses provided via the listener are behaving as they * should. */ @Test public void timeLapseSafety() { final List<IllegalArgumentException> failures = new ArrayList<>(); getModel().register(new LimitingTickListener(getModel(), 3)); getModel().register(new TickListener() { @Override public void tick(TimeLapse timeLapse) { timeLapse.consume(1L); } @Override public void afterTick(TimeLapse timeLapse) { try { timeLapse.consume(1L); } catch (final IllegalArgumentException e) { failures.add(e); } } }); getModel().start(); assertThat(getModel().isTicking()).isFalse(); assertThat(failures).hasSize(3); }
final void tickImpl() { for (final TickListener t : tickListeners) { timeLapse.reset(); t.tick(timeLapse); } // in the after tick the TimeLapse can no longer be consumed timeLapse.consumeAll(); for (final TickListener t : tickListeners) { t.afterTick(timeLapse); } // advance time timeLapse.next(); if (Thread.interrupted() && isTicking()) { LOGGER.info("Simulation interrupted after tick {}, stopping.", timeLapse); stop(); } }
/** * Test static properties of time model. */ @Test public void testDefaultProperties() { assertThat(getModel().getTickListeners()).isEmpty(); assertThat(getModel().getCurrentTime()).isEqualTo(0L); assertThat(getModel().isTicking()).isFalse(); }
/** * Sets up a fake dependency provider and a working model instance. */ @Before public void setUp() { clock = spy((RealtimeClockController) TimeModel.builder() .withRealTime() .build(FakeDependencyProvider.empty())); doNothing().when(clock).switchToRealTime(); doNothing().when(clock).switchToSimulatedTime(); final RoadModelSnapshot planeSnapshot = RoadModelSnapshotTestUtil.createPlaneRoadModelSnapshot(new Point(0, 0), new Point(10, 10), SI.KILOMETER); final PDPRoadModel rm = mock(PDPRoadModel.class); when(rm.getSpeedUnit()).thenReturn(NonSI.KILOMETERS_PER_HOUR); when(rm.getDistanceUnit()).thenReturn(SI.KILOMETER); when(rm.getSnapshot()).thenReturn(planeSnapshot); dependencyProvider = FakeDependencyProvider.builder() .add(clock, RealtimeClockController.class) .add(rm, PDPRoadModel.class) .add(DefaultPDPModel.builder()) .build(); model = RtSolverModel.builder().build(dependencyProvider); ((TimeModel) clock).register(model); assertThat(model.mode).isEqualTo(Mode.UNKNOWN); TestUtil.testEnum(Mode.class); TestUtil.testEnum(RtSimSolver.EventType.class); }
@Before public void setUp() { sim = Simulator.builder() .addModel(TimeModel.builder() .withRealTime() .withTickLength(100L) .withTimeUnit(SI.MILLI(SI.SECOND))) .addModel(PDPRoadModel.builder(RoadModelBuilders.plane())) .addModel(DefaultPDPModel.builder()) .addModel(RtSolverModel.builder() .withSingleMode() .withThreadGrouping(useThreadGrouping)) .build(); model = sim.getModelProvider().getModel(RtSolverModel.class); rtClock = sim.getModelProvider().getModel(TimeModel.class) .get(RealtimeClockController.class); sim.register(new Depot(new Point(5, 5))); sim.register(new RouteFollowingVehicle(VehicleDTO.builder().build(), true)); }
/** * Basic register/unregister tests. */ @Test public void testTicks() { final TickListenerChecker a = checker(); final LimitingTickListener ltl = new LimitingTickListener(getModel(), 1); a.assertCountEquals(0L); assertThat(getModel().register(a)).isTrue(); assertThat(getModel().register(ltl)).isTrue(); assertThat(getModel().getTickListeners()).containsExactly(a, ltl).inOrder(); getModel().start(); assertThat(getModel().getCurrentTime()).isEqualTo( getModel().getTickLength()); assertThat(a.getTickCount()).isEqualTo(1L); getModel().unregister(a); assertThat(getModel().getTickListeners()).containsExactly(ltl); assertThat(a.getTickCount()).isEqualTo(1L); // re-register assertThat(getModel().register(a)).isTrue(); assertThat(getModel().getTickListeners()).containsExactly(ltl, a).inOrder(); }
public void testEvents() { final ListenerEventHistory leh = new ListenerEventHistory(); getModel().getEventAPI().addListener(leh, ClockEventType.values()); getModel().register(new LimitingTickListener(getModel(), 2)); getModel().register(new TickListener() { @Override public void tick(TimeLapse timeLapse) { assertThat(intervals).isEmpty(); assertThat(leh.getEventTypeHistory()).isEmpty(); getModel().start(); assertThat(intervals).hasSize(2); assertThat(intervals).containsExactly( Range.openClosed(0L, model.getTickLength()), Range.openClosed(model.getTickLength(), model.getTickLength() * 2)) .inOrder(); assertThat(leh.getEventTypeHistory()).containsExactly(
assertThat(getModel().register(a)).isTrue(); assertThat(getModel().register(b)).isTrue(); assertThat(getModel().register(c)).isTrue(); assertThat(getModel().register(d)).isTrue(); assertThat(getModel().register(new LimitingTickListener(getModel(), 4))) .isTrue(); getModel().start(); assertThat(getModel().getCurrentTime()).isEqualTo( 4 * getModel().getTickLength());
/** * Tests that an exception thrown inside a {@link TickListener} is nicely * propagated. */ @Test public void testExceptionPropagation() { getModel().register(new TickListener() { @Override public void tick(TimeLapse timeLapse) { throw new IllegalArgumentException("YOLO"); } @Override public void afterTick(TimeLapse timeLapse) {} }); boolean fail = false; try { getModel().start(); } catch (final IllegalArgumentException e) { fail = true; assertThat(e.getMessage()).isEqualTo("YOLO"); } assertThat(fail).isTrue(); }
/** * Tests that STOPPED event is dispatched when an exception occurs. */ @Test public void testStoppedEventOnException() { final ListenerEventHistory history = new ListenerEventHistory(); getModel().getEventAPI().addListener(history, Clock.ClockEventType.STOPPED); getModel().register(new TickListener() { @Override public void tick(TimeLapse timeLapse) { if (timeLapse.getStartTime() >= 300) { throw new IllegalStateException("Test"); } } @Override public void afterTick(TimeLapse timeLapse) {} }); boolean failure = false; try { getModel().start(); } catch (final IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Test"); assertThat(history.getEventTypeHistory()).containsExactly( ClockEventType.STOPPED); failure = true; } assertThat(failure).isTrue(); }
/** * Tests that adding a listener twice yields no result. */ @Test public void testAddListenerTwice() { final TickListener a = checker(); getModel().register(a); boolean fail = false; try { getModel().register(a); } catch (final IllegalArgumentException e) { fail = true; } assertThat(fail).isTrue(); assertThat(getModel().getTickListeners()).containsExactly(a); }
((TimeModel) clock).register(new TickListener() { @Override public void tick(TimeLapse timeLapse) {
@Override void cleanUpAfterException() { LOGGER.trace("cleanUpAfterException"); shutdownExecutor(); super.cleanUpAfterException(); }
/** * Tests that trying to start the time twice is prevented. */ @Test public void testStartStart() { getModel().register(new TickListener() { @Override public void tick(TimeLapse timeLapse) { // this should throw an exception to prevent inception to take place getModel().start(); } @Override public void afterTick(TimeLapse timeLapse) {} }); boolean fail = false; try { getModel().start(); } catch (final IllegalStateException e) { assertThat(e.getMessage()).contains("Time is already ticking."); fail = true; } assertThat(fail).isTrue(); }
@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 that listeners are called in order of adding to model. */ @Test public void testTickOrder() { final TickListenerChecker a = checker(); final TickListenerChecker b = checker(); getModel().register(a); getModel().register(b); getModel().register(new LimitingTickListener(getModel(), 1)); getModel().start(); assertThat(b.getLastTickTime() - a.getLastTickTime()).isAtLeast(0L); assertThat(a.getLastAfterTickTime() - b.getLastTickTime()).isAtLeast(0L); assertThat(b.getLastAfterTickTime() - a.getLastAfterTickTime()) .isAtLeast(0L); }
@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(); }