How to use

com.github.rinde.rinsim.event.ListenerEventHistory

constructor

@Before
public void setup() {
 l1 = new ListenerEventHistory();
 l2 = new ListenerEventHistory();
 l3 = new ListenerEventHistory();
 dispatcher = new EventDispatcher(EVENT1, EVENT2, EVENT3);
 api = dispatcher.getPublicEventAPI();
}

@Test
public void followPathEventIssuerType() {
 final MovingRoadUser user = new TestRoadUser();
 model.addObjectAt(user, SW);
 final ListenerEventHistory list = new ListenerEventHistory();
 model.getEventAPI().addListener(list, RoadEventType.MOVE);
 assertTrue(list.getHistory().isEmpty());
 model.followPath(user, newLinkedList(asList(SW, SE, NE, NW)),
  TimeLapseFactory.create(0, 10));
 assertEquals(1, list.getHistory().size());
 assertEquals(RoadEventType.MOVE, list.getHistory().get(0).getEventType());
 assertEquals(model, list.getHistory().get(0).getIssuer());
}

final ListenerEventHistory eventHistory = new ListenerEventHistory();
solvers.get(0).solve(SolveArgs.create());
verify(clock, times(1)).switchToRealTime();

@Test
public void moveToEventIssuerType() {
 final MovingRoadUser user = new TestRoadUser();
 model.addObjectAt(user, SW);
 final ListenerEventHistory list = new ListenerEventHistory();
 model.getEventAPI().addListener(list, RoadEventType.MOVE);
 assertTrue(list.getHistory().isEmpty());
 model.moveTo(user, NW, TimeLapseFactory.create(0, 10));
 assertEquals(1, list.getHistory().size());
 assertEquals(RoadEventType.MOVE, list.getHistory().get(0).getEventType());
 assertEquals(model, list.getHistory().get(0).getIssuer());
}

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

final ListenerEventHistory history = new ListenerEventHistory();
fsm.getEventAPI()
 .addListener(history, StateMachine.StateMachineEvent.values());

/**
 * Tests that the same device is used again upon re-registering.
 */
@Test
public void testRegisterUnregistered() {
 final ListenerEventHistory leh = new ListenerEventHistory();
 model.getEventAPI().addListener(leh, EventTypes.ADD_COMM_USER,
  EventTypes.REMOVE_COMM_USER);
 final CommDevice originalDevice = agent1.device();
 assertThat(model.contains(agent1)).isTrue();
 model.unregister(agent1);
 assertThat(model.contains(agent1)).isFalse();
 assertThat(leh.getEventTypeHistory()).containsExactly(REMOVE_COMM_USER)
  .inOrder();
 model.register(agent1);
 assertThat(model.contains(agent1)).isTrue();
 final CommDevice newDevice = agent1.device();
 assertThat(originalDevice).isSameAs(newDevice);
 assertThat(leh.getEventTypeHistory()).containsExactly(REMOVE_COMM_USER,
  ADD_COMM_USER)
  .inOrder();
 newDevice.broadcast(Contents.HELLO_WORLD);
}

getModel().switchToSimulatedTime();
assertThat(getModel().getClockMode()).isEqualTo(ClockMode.SIMULATED);
final ListenerEventHistory history = new ListenerEventHistory();
getModel().getEventAPI().addListener(history,
 ImmutableSet.<Enum<?>>builder()

/**
 * Test event dispatching.
 */
@Test
public void testEvent() {
 final ListenerEventHistory history = new ListenerEventHistory();
 model.getEventAPI().addListener(history, EventTypes.ADD_COMM_USER);
 final CommUser agent6 = new RangedAgent(new Point(6, 6), 4);
 model.register(agent6);
 assertEquals(1, history.getHistory().size());
 assertTrue(history.getHistory().get(0) instanceof CommModelEvent);
 final CommModelEvent event = (CommModelEvent) history.getHistory().get(0);
 assertSame(agent6, event.getUser());
 assertSame(model, event.getIssuer());
 assertSame(agent6,
  model.getUsersAndDevices().inverse().get(event.getDevice()));
}

ListenerEventHistory history = new ListenerEventHistory();
graph1.getEventAPI().addListener(history);
graph1.merge(graph2);

final ListenerEventHistory leh = new ListenerEventHistory();
getModel().getEventAPI().addListener(leh, ClockEventType.values());

final ListenerEventHistory leh = new ListenerEventHistory();
d.stateMachine.getEventAPI().addListener(leh,
 StateMachineEvent.STATE_TRANSITION);

ListenerEventHistory history = new ListenerEventHistory();
ListenableGraph<LengthData> graph = new ListenableGraph<>(
 new MultimapGraph<LengthData>());

final ListenerEventHistory leh = new ListenerEventHistory();
controller.getEventAPI().addListener(leh);

/**
 * Test starting and stopping time.
 */
@Test
public void testStartStop() {
 final LimitingTickListener ltl = new LimitingTickListener(getModel(), 3);
 final ListenerEventHistory leh = new ListenerEventHistory();
 getModel().getEventAPI().addListener(leh, ClockEventType.values());
 getModel().register(ltl);
 getModel().start();
 assertEquals(3 * getModel().getTickLength(), getModel().getCurrentTime());
 getModel().start();
 assertEquals(6 * getModel().getTickLength(), getModel().getCurrentTime());
 assertThat(leh.getEventTypeHistory()).isEqualTo(
  asList(
   ClockEventType.STARTED,
   ClockEventType.STOPPED,
   ClockEventType.STARTED,
   ClockEventType.STOPPED));
}

 ScenarioController.class);
final ListenerEventHistory leh = new ListenerEventHistory();
sc.getEventAPI().addListener(leh);
assertThat(sc.isScenarioFinished()).isFalse();

@Test
public void testTransition() {
 final ListenerEventHistory history = new ListenerEventHistory();
 fsm.getEventAPI()
  .addListener(history, StateMachine.StateMachineEvent.values());

 .build();
final ListenerEventHistory leh = new ListenerEventHistory();
final ScenarioController sc = sim.getModelProvider().getModel(
 ScenarioController.class);

assertFalse(dispatcher.containsListener(l2, OTHER_EVENT1));
dispatcher.removeListener(new ListenerEventHistory());