private void fireError(byte[] address, int errorCode, byte[] reasonData) { LOGGER .error("Error received from system, addr: {}, errorCode: {}, reasonData: {}", address, errorCode, reasonData); synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.error(address, errorCode, reasonData); } } }
protected void fireBoosterState(byte[] address, BoosterState state) { synchronized (messageListeners) { Set<MessageListener> safeListeners = Collections.unmodifiableSet(messageListeners); for (MessageListener l : safeListeners) { l.boosterState(address, state); } } }
private void fireOccupied(byte[] address, int detectorNumber, Long timestamp) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.occupation(address, detectorNumber, OccupationState.OCCUPIED, timestamp); } } }
@Test public void receiveMessageTest() throws IOException { byte[] address = new byte[] { 0 }; NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); // prepare the object to test NetMessageReceiver receiver = new NetMessageReceiver(nodeFactory, false); receiver.addMessageListener(messageListener); // set the receive queue byte[] data = new byte[] { 0x05, 0x00, 0x01, (byte) 0x86, (byte) 0x02, (byte) 0x00, 0x06, 0x00, 0x01, (byte) 0xc1, 0x00, 0x01, 0x02 }; Mockito.when(nodeFactory.findNode(address)).thenReturn(bidibNode); Mockito.when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(1)); receiver.receive(pack(data)); // verify that error was called once Mockito.verify(messageListener, Mockito.times(1)).error(address, 2, address); Mockito.verify(messageListener, Mockito.times(1)).lcNa(Mockito.eq(address), Mockito.any(), Mockito.eq(2)); } }
private void fireLcConfigX(LcConfigXResponse lcConfigXResponse) { byte[] address = lcConfigXResponse.getAddr(); LcConfigX lcConfigX = lcConfigXResponse.getLcConfigX(); synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.lcConfigX(address, lcConfigX); } } // check if the config is finished if (!lcConfigX.isContinueDetected()) { // notify the bulk sender notifyBulkSender(lcConfigXResponse.getAddr(), LcConfigXResponse.TYPE); } else { LOGGER.info("Continue detected in LcConfigX."); } }
private void fireLcNa(LcNotAvailableResponse lcNotAvailableResponse) { byte[] address = lcNotAvailableResponse.getAddr(); final BidibPort bidibPort = lcNotAvailableResponse.getBidibPort(); Integer errorCode = lcNotAvailableResponse.getErrorCode(); synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.lcNa(address, bidibPort, errorCode); } } // notify the bulk sender notifyBulkSender(address, LcNotAvailableResponse.TYPE); }
protected void fireConfidence(byte[] address, int valid, int freeze, int signal) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.confidence(address, valid, freeze, signal); } } }
protected void fireBoosterDiagnostic(byte[] address, int current, int voltage, int temperature) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.boosterDiag(address, current, voltage, temperature); } } }
protected void fireAddress(byte[] address, int detectorNumber, List<AddressData> addresses) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.address(address, detectorNumber, addresses); } } }
private void fireAccessoryState( byte[] address, final AccessoryState accessoryState, final AccessoryStateOptions accessoryStateOptions) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.accessoryState(address, accessoryState, accessoryStateOptions); } } // notify the bulk sender notifyBulkSender(address, AccessoryStateResponse.TYPE); }
@Test public void receive4Test() throws IOException, ProtocolException { NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] rawmessage = { 0x08, 0x03, 0x00, 0x1E, (byte) 0xC6, 0x00, 0x07, 0x00, 0x00, 0x08, 0x03, 0x00, 0x1F, (byte) 0xC6, 0x00, 0x08, 0x00, 0x00, 0x08, 0x03, 0x00, 0x20, (byte) 0xC6, 0x00, 0x09, 0x00, 0x00, 0x08, 0x03, 0x00, 0x21, (byte) 0xC6, 0x00, 0x0A, 0x00, 0x00, 0x08, 0x03, 0x00, 0x22, (byte) 0xC6, 0x00, 0x0B, 0x00, 0x00, 0x08, 0x03, 0x00, 0x23, (byte) 0xC6, 0x00, 0x0C, 0x00, 0x00, 0x08, 0x03, 0x00, 0x24, (byte) 0xC6, 0x00, 0x0D, 0x00, 0x00, (byte) 0xF5, (byte) 0xFE }; byte[] message = new byte[] { 0x08, 0x03, 0x00, 0x17, (byte) 0xC6, 0x00, 0x00, 0x00, 0x00 }; final byte[] nodeAddress = new byte[] { 3 }; Mockito.when(nodeFactory.findNode(nodeAddress)).thenReturn(bidibNode); Mockito .when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(0x1E), Integer.valueOf(0x1F), Integer.valueOf(0x20), Integer.valueOf(0x21), Integer.valueOf(0x22), Integer.valueOf(0x23), Integer.valueOf(0x24)); receiver.receive(pack(rawmessage)); BidibMessage response = new BidibResponseFactory().create(message); // verify that message was signaled Mockito.verify(messageListener, Mockito.times(7)).lcConfigX(Mockito.eq(nodeAddress), Mockito.any()); Assert.assertEquals(response.getType(), ByteUtils.getLowByte(BidibLibrary.MSG_LC_CONFIGX)); }
@Test public void receiveMessageTest() throws IOException { byte[] address = new byte[] { 0 }; NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); // prepare the object to test SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] data = new byte[] { 0x05, 0x00, 0x01, (byte) 0x86, (byte) 0x02, (byte) 0x00, (byte) 0x46, (byte) 0xFE }; Mockito.when(nodeFactory.findNode(address)).thenReturn(bidibNode); Mockito.when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(1)); receiver.receive(pack(data)); // verify that error was called once Mockito.verify(messageListener, Mockito.times(1)).error(address, 2, address); }
@Test public void receive5Test() throws IOException, ProtocolException { NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] rawmessage = { 0x08, 0x03, 0x00, 0x25, (byte) 0xC6, 0x00, 0x0E, 0x00, 0x00, 0x08, 0x03, 0x00, 0x26, (byte) 0xC6, 0x00, 0x0F, 0x00, 0x00, (byte) 0xDA, (byte) 0xFE }; byte[] message = new byte[] { 0x08, 0x03, 0x00, 0x17, (byte) 0xC6, 0x00, 0x00, 0x00, 0x00 }; final byte[] nodeAddress = new byte[] { 3 }; Mockito.when(nodeFactory.findNode(nodeAddress)).thenReturn(bidibNode); Mockito .when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))) .thenReturn(Integer.valueOf(0x25), Integer.valueOf(0x26)); receiver.receive(pack(rawmessage)); BidibMessage response = new BidibResponseFactory().create(message); // verify that message was signaled Mockito.verify(messageListener, Mockito.times(2)).lcConfigX(Mockito.eq(nodeAddress), Mockito.any()); Assert.assertEquals(response.getType(), ByteUtils.getLowByte(BidibLibrary.MSG_LC_CONFIGX)); }
private void fireFree(byte[] address, int detectorNumber, Long timestamp) { synchronized (messageListeners) { for (MessageListener l : messageListeners) { l.occupation(address, detectorNumber, OccupationState.FREE, timestamp); } } }
@Test public void receiveBoostStatResponseTest() throws IOException { byte[] address = new byte[] { 0 }; NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] data = new byte[] { 0x04, 0x00, 0x3a, (byte) 0xb0, (byte) 0x06, (byte) 0x74, (byte) 0xFE }; final byte[] nodeAddress = new byte[] { 0 }; Mockito.when(nodeFactory.findNode(nodeAddress)).thenReturn(bidibNode); Mockito.when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(58)); receiver.receive(pack(data)); // verify that booster state is on Mockito.verify(messageListener, Mockito.never()).boosterState(address, BoosterState.ON); }
@Test public void receiveMessageLeadingMagicTest() throws IOException { byte[] address = new byte[] { 0 }; NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); // prepare the object to test SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] data = new byte[] { (byte) 0xFE, 0x05, 0x00, 0x01, (byte) 0x86, (byte) 0x02, (byte) 0x00, (byte) 0x46, (byte) 0xFE }; Mockito.when(nodeFactory.findNode(address)).thenReturn(bidibNode); Mockito.when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(1)); receiver.receive(pack(data)); // verify that error was called once Mockito.verify(messageListener, Mockito.times(1)).error(address, 2, address); }
Mockito.verify(messageListener, Mockito.times(7)).lcConfigX(Mockito.eq(nodeAddress), Mockito.any());
Mockito.verify(messageListener, Mockito.never()).occupation(address, 2, OccupationState.OCCUPIED, null); Mockito.verify(messageListener, Mockito.times(1)).occupation(address, 0, OccupationState.FREE, null); Mockito.verify(messageListener, Mockito.times(1)).occupation(address, 2, OccupationState.FREE, null); Mockito.verify(messageListener, Mockito.times(1)).occupation(address, 7, OccupationState.FREE, null); Mockito.verify(messageListener, Mockito.times(1)).occupation(address, 8, OccupationState.OCCUPIED, null);
@Test public void receiveMessageAddrStackTest() throws IOException { byte[] address = new byte[] { 1, 2, 3 }; NodeRegistry nodeFactory = Mockito.mock(NodeRegistry.class); BidibNode bidibNode = Mockito.mock(BidibNode.class); MessageListener messageListener = Mockito.mock(MessageListener.class); // prepare the object to test SerialMessageReceiver receiver = new SerialMessageReceiver(nodeFactory); receiver.addMessageListener(messageListener); // set the receive queue byte[] data = new byte[] { 0x0B, 0x01, 0x02, 0x03, 0x00, 0x01, (byte) 0x86, SysErrorEnum.BIDIB_ERR_ADDRSTACK.getType(), (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x56, (byte) 0xFE }; Mockito.when(nodeFactory.findNode(address)).thenReturn(bidibNode); Mockito.when(bidibNode.getNextReceiveMsgNum(Mockito.any(BidibMessage.class))).thenReturn(Integer.valueOf(1)); receiver.receive(pack(data)); // verify that error was called once Mockito .verify(messageListener, Mockito.times(1)) .error(address, SysErrorEnum.BIDIB_ERR_ADDRSTACK.getType(), new byte[] { 1, 2, 3, 4 }); }
Mockito.verify(messageListener, Mockito.times(1)).lcConfigX(nodeAddress, lcConfigXResponse.getLcConfigX());