/** * Unregister a previously registered key listener. * * @param key The key this listener was previously registered to * receive updates on. * @param listener The listener to remove. */ public void removeListener(MessageKey key, VehicleMessage.Listener listener) { removeListener(ExactKeyMatcher.buildExactMatcher(key), listener); }
/** * Register to receive a callback when a message with the given key is * received. * * @param key The key you want to receive updates. * @param listener An listener instance to receive the callback. */ public void addListener(MessageKey key, VehicleMessage.Listener listener) { addListener(ExactKeyMatcher.buildExactMatcher(key), listener); }
public static ExactKeyMatcher buildExactMatcher(final KeyedMessage keyed) { return buildExactMatcher(keyed.getKey()); }
@Test public void exactMatcherDoesntMatchDifferentExactMatcher() { assertThat(ExactKeyMatcher.buildExactMatcher(keyed), not(equalTo(ExactKeyMatcher.buildExactMatcher(different)))); }
@Test public void differentHashCode() { assertThat(ExactKeyMatcher.buildExactMatcher(keyed).hashCode(), not(equalTo(ExactKeyMatcher.buildExactMatcher( different).hashCode()))); }
@Test public void wildcardDoesNotEqualOther() { KeyMatcher wildcard = KeyMatcher.getWildcardMatcher(); KeyMatcher exact = ExactKeyMatcher.buildExactMatcher(keyed); assertThat(wildcard, not(equalTo(exact))); }
@Test public void exactMatcherMatchesAnotherExactMatcher() { KeyedMessage another = new TestKeyedMessage(); assertEquals(ExactKeyMatcher.buildExactMatcher(keyed), ExactKeyMatcher.buildExactMatcher(another)); }
/** * Send a message to the VehicleInterface and register the given listener to * receive the first response matching the message's key. * * This function is non-blocking. * * The listener is unregistered after the first response is received. If you * need to accept multiple responses for the same request, you must manually * register your own listener to control its lifecycle. * * @param message The desired message to send to the vehicle. * @param listener The message listener that should receive a callback when * a response matching the outgoing message's key is received from the * VI. */ public void request(KeyedMessage message, VehicleMessage.Listener listener) { // Register the listener as non-persistent, so it is deleted after // receiving the first response mNotifier.register(ExactKeyMatcher.buildExactMatcher(message.getKey()), listener, false); send(message); }
@Test public void sameHashCode() { assertEquals(ExactKeyMatcher.buildExactMatcher(keyed).hashCode(), ExactKeyMatcher.buildExactMatcher(keyed).hashCode()); }
@Test public void removeMessageListener() throws UnrecognizedMeasurementTypeException, DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.unregister(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(message); sink.clearQueue(); assertThat(listener.received, nullValue()); }
@Test public void exactMatcherMatchesOriginal() { KeyMatcher matcher = ExactKeyMatcher.buildExactMatcher(keyed); assertTrue(matcher.matches(keyed)); }
@Test public void nullNotEqualToExact() { KeyMatcher matcher = ExactKeyMatcher.buildExactMatcher(keyed); assertFalse(matcher.equals(null)); }
@Test public void listenerRecievesMessageContinually() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(message); sink.clearQueue(); assertThat(listener.received, notNullValue()); assertEquals(listener.received, message); listener.received = null; sink.receive(message); assertThat(listener.received, nullValue()); }
@Test public void nonpersistentRemovedAfterOne() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener, false); sink.receive(message); sink.clearQueue(); assertThat(listener.received, notNullValue()); assertEquals(listener.received, message); listener.received = null; sink.receive(message); assertThat(listener.received, nullValue()); }
@Test public void messageAndMeasurementListenersBothReceive() throws DataSinkException, UnrecognizedMeasurementTypeException { VehicleSpeed speed = new VehicleSpeed(42.0); VehicleMessage message = speed.toVehicleMessage(); sink.register(ExactKeyMatcher.buildExactMatcher((KeyedMessage) message), listener); sink.register(speed.getClass(), speedListener); sink.receive(speed.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, notNullValue()); assertThat(listener.received, notNullValue()); }
@Test public void receiveNonMatchingNotPropagated() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); message = new NamedVehicleMessage("bar"); sink.receive(message); sink.clearQueue(); assertThat(listener.received, nullValue()); }
@Test public void listenerRecievesMessage() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(message); sink.clearQueue(); assertThat(listener.received, notNullValue()); assertEquals(listener.received, message); }
@Test public void exactMatcherMatchesMessageWithSameKey() { KeyMatcher matcher = ExactKeyMatcher.buildExactMatcher(keyed); KeyedMessage another = new TestKeyedMessage(); assertTrue(matcher.matches(another)); }
@Test public void matchesKeyFromCommand() { Command originalCommand = new Command(command); KeyMatcher matcher = ExactKeyMatcher.buildExactMatcher(originalCommand); assertTrue(matcher.matches(response)); } }
@Test public void nonKeyedIgnored() throws DataSinkException { KeyedMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(new VehicleMessage()); }