/** * 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); }
/** * 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(); }
/** * 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 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); }
/** * 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); }
/** * 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); }
/** * 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(); }
/** * 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(); }
((TimeModel) clock).register(new TickListener() { @Override public void tick(TimeLapse timeLapse) {