Java tutorial
/** * Copyright (c) 2010-2019 by the respective copyright holders. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html */ package org.openhab.binding.modbus.internal; import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.assertThat; import static org.mockito.Matchers.any; import static org.mockito.Mockito.*; import java.io.File; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.Socket; import java.net.SocketException; import java.net.UnknownHostException; import java.util.Dictionary; import java.util.Hashtable; import org.apache.commons.lang.NotImplementedException; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.Spy; import org.openhab.core.events.EventPublisher; import org.openhab.core.library.items.NumberItem; import org.openhab.core.library.items.SwitchItem; import org.openhab.core.library.types.OnOffType; import org.openhab.core.types.State; import org.openhab.model.item.binding.BindingConfigParseException; import gnu.io.SerialPort; import net.wimpi.modbus.Modbus; import net.wimpi.modbus.ModbusCoupler; import net.wimpi.modbus.ModbusIOException; import net.wimpi.modbus.io.ModbusTransport; import net.wimpi.modbus.msg.ModbusRequest; import net.wimpi.modbus.net.ModbusSerialListener; import net.wimpi.modbus.net.ModbusTCPListener; import net.wimpi.modbus.net.ModbusUDPListener; import net.wimpi.modbus.net.SerialConnection; import net.wimpi.modbus.net.SerialConnectionFactory; import net.wimpi.modbus.net.TCPSlaveConnection; import net.wimpi.modbus.net.TCPSlaveConnection.ModbusTCPTransportFactory; import net.wimpi.modbus.net.TCPSlaveConnectionFactory; import net.wimpi.modbus.net.UDPSlaveTerminal; import net.wimpi.modbus.net.UDPSlaveTerminal.ModbusUDPTransportFactoryImpl; import net.wimpi.modbus.net.UDPSlaveTerminalFactory; import net.wimpi.modbus.net.UDPTerminal; import net.wimpi.modbus.procimg.SimpleProcessImage; import net.wimpi.modbus.util.AtomicCounter; import net.wimpi.modbus.util.SerialParameters; public class TestCaseSupport { public enum ServerType { TCP, UDP, SERIAL } /** * Servers to test * Serial is system dependent */ public static final ServerType[] TEST_SERVERS = new ServerType[] { ServerType.TCP // ServerType.UDP, // ServerType.SERIAL }; // One can perhaps test SERIAL with https://github.com/freemed/tty0tty // and using those virtual ports? Not the same thing as real serial device of course private static String SERIAL_SERVER_PORT = "/dev/pts/7"; private static String SERIAL_CLIENT_PORT = "/dev/pts/8"; private static SerialParameters SERIAL_PARAMETERS_CLIENT = new SerialParameters(SERIAL_CLIENT_PORT, 115200, SerialPort.FLOWCONTROL_NONE, SerialPort.FLOWCONTROL_NONE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE, Modbus.SERIAL_ENCODING_ASCII, false, 1000); private static SerialParameters SERIAL_PARAMETERS_SERVER = new SerialParameters(SERIAL_SERVER_PORT, SERIAL_PARAMETERS_CLIENT.getBaudRate(), SERIAL_PARAMETERS_CLIENT.getFlowControlIn(), SERIAL_PARAMETERS_CLIENT.getFlowControlOut(), SERIAL_PARAMETERS_CLIENT.getDatabits(), SERIAL_PARAMETERS_CLIENT.getStopbits(), SERIAL_PARAMETERS_CLIENT.getParity(), SERIAL_PARAMETERS_CLIENT.getEncoding(), SERIAL_PARAMETERS_CLIENT.isEcho(), 1000); static { System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "trace"); System.setProperty("gnu.io.rxtx.SerialPorts", SERIAL_SERVER_PORT + File.pathSeparator + SERIAL_CLIENT_PORT); } /** * Max time to wait for connections/requests from client */ protected int MAX_WAIT_REQUESTS_MILLIS = 1000; /** * The server runs in single thread, only one connection is accepted at a time. * This makes the tests as strict as possible -- connection must be closed. */ private static final int SERVER_THREADS = 1; // "infinity", we execute manually manually protected static long REFRESH_INTERVAL = 1000000L; protected static String SLAVE_NAME = "slave1"; protected static String SLAVE2_NAME = "slave2"; protected static int SLAVE_UNIT_ID = 1; private static AtomicCounter udpServerIndex = new AtomicCounter(0); @Mock protected EventPublisher eventPublisher; @Spy protected TCPSlaveConnectionFactory tcpConnectionFactory = new TCPSlaveConnectionFactoryImpl(); @Spy protected UDPSlaveTerminalFactory udpTerminalFactory = new UDPSlaveTerminalFactoryImpl(); @Spy protected SerialConnectionFactory serialConnectionFactory = new SerialConnectionFactoryImpl(); protected ResultCaptor<ModbusRequest> modbustRequestCaptor; protected ModbusBinding binding; protected ModbusTCPListener tcpListener; protected ModbusUDPListener udpListener; protected ModbusSerialListener serialListener; protected SimpleProcessImage spi; protected int tcpModbusPort = -1; protected int udpModbusPort = -1; protected ServerType serverType = ServerType.TCP; protected long artificialServerWait = 0; private Thread serialServerThread = new Thread("ModbusBindingTestsSerialServer") { @Override public void run() { serialListener = new ModbusSerialListener(SERIAL_PARAMETERS_SERVER); }; }; protected static InetAddress localAddress() throws UnknownHostException { return InetAddress.getLocalHost(); } protected static Dictionary<String, Object> addSlave(Dictionary<String, Object> config, ServerType serverType, String connection, String slaveName, String type, String valuetype, int slaveId, int start, int length) { /** * Add a modbus slave to config */ putSlaveConfigParameter(config, serverType, slaveName, "connection", connection); putSlaveConfigParameter(config, serverType, slaveName, "id", String.valueOf(slaveId)); putSlaveConfigParameter(config, serverType, slaveName, "type", type); if (valuetype != null) { putSlaveConfigParameter(config, serverType, slaveName, "valuetype", valuetype); } putSlaveConfigParameter(config, serverType, slaveName, "start", String.valueOf(start)); putSlaveConfigParameter(config, serverType, slaveName, "length", String.valueOf(length)); return config; } /** * Add slave to config using configured serverType */ protected Dictionary<String, Object> addSlave(Dictionary<String, Object> config, String slaveName, String type, String valuetype, int start, int length) throws UnknownHostException { String connection; if (ServerType.TCP.equals(serverType)) { int port = tcpModbusPort; connection = String.format("%s:%d", localAddress().getHostAddress(), port); } else if (ServerType.UDP.equals(serverType)) { int port = udpModbusPort; connection = String.format("%s:%d", localAddress().getHostAddress(), port); } else if (ServerType.SERIAL.equals(serverType)) { connection = String.format("%s:%d:%d:%s:%s:%s", SERIAL_PARAMETERS_CLIENT.getPortName(), SERIAL_PARAMETERS_CLIENT.getBaudRate(), SERIAL_PARAMETERS_CLIENT.getDatabits(), SERIAL_PARAMETERS_CLIENT.getParityString(), SERIAL_PARAMETERS_CLIENT.getStopbitsString(), SERIAL_PARAMETERS_CLIENT.getEncoding()); } else { throw new NotImplementedException(); } return addSlave(config, serverType, connection, slaveName, type, valuetype, 1, start, length); } protected static void putSlaveConfigParameter(Dictionary<String, Object> config, ServerType serverType, String slaveName, String paramName, String paramValue) { String protocol = null; if (ServerType.TCP.equals(serverType)) { protocol = "tcp"; } else if (ServerType.UDP.equals(serverType)) { protocol = "udp"; } else if (ServerType.SERIAL.equals(serverType)) { protocol = "serial"; } config.put(String.format("%s.%s.%s", protocol, slaveName, paramName), paramValue); } protected static Dictionary<String, Object> newLongPollBindingConfig() { Dictionary<String, Object> config = new Hashtable<>(); config.put("poll", String.valueOf(REFRESH_INTERVAL)); return config; } protected void configureSwitchItemBinding(int items, String slaveName, int itemOffset, String itemPrefix, State initialState) throws BindingConfigParseException { Assert.assertEquals(REFRESH_INTERVAL, binding.getRefreshInterval()); final ModbusGenericBindingProvider provider = new ModbusGenericBindingProvider(); for (int itemIndex = itemOffset; itemIndex < items + itemOffset; itemIndex++) { SwitchItem item = new SwitchItem(String.format("%sItem%d", itemPrefix, itemIndex + 1)); if (initialState != null) { item.setState(initialState); } provider.processBindingConfiguration("test.items", item, String.format("%s:%d", slaveName, itemIndex)); } binding.setEventPublisher(eventPublisher); binding.addBindingProvider(provider); } protected void configureSwitchItemBinding(int items, String slaveName, int itemOffset) throws BindingConfigParseException { configureSwitchItemBinding(items, slaveName, itemOffset, "", null); } protected void configureNumberItemBinding(int items, String slaveName, int itemOffset, String itemPrefix, State initialState) throws BindingConfigParseException { Assert.assertEquals(REFRESH_INTERVAL, binding.getRefreshInterval()); final ModbusGenericBindingProvider provider = new ModbusGenericBindingProvider(); for (int itemIndex = itemOffset; itemIndex < items + itemOffset; itemIndex++) { NumberItem item = new NumberItem(String.format("%sItem%d", itemPrefix, itemIndex + 1)); if (initialState != null) { item.setState(initialState); } provider.processBindingConfiguration("test.items", item, String.format("%s:%d", slaveName, itemIndex)); } binding.setEventPublisher(eventPublisher); binding.addBindingProvider(provider); } protected void configureNumberItemBinding(int items, String slaveName, int itemOffset) throws BindingConfigParseException { configureNumberItemBinding(items, slaveName, itemOffset, "", null); } protected void verifyBitItems(String expectedBits, int itemOffset, String itemPrefix) { for (int bitIndex = 0; bitIndex < expectedBits.length(); bitIndex++) { char bit = expectedBits.charAt(bitIndex); State state; if (bit == '0') { state = OnOffType.OFF; } else if (bit == '1') { state = OnOffType.ON; } else { throw new RuntimeException("invalid testdata"); } verify(eventPublisher).postUpdate(String.format("%sItem%d", itemPrefix, bitIndex + itemOffset + 1), state); } } protected void verifyBitItems(String expectedBits, int itemOffset) { verifyBitItems(expectedBits, itemOffset, ""); } protected void verifyBitItems(String expectedBits) { verifyBitItems(expectedBits, 0, ""); } @Before public void setUp() throws Exception { modbustRequestCaptor = new ResultCaptor<>(artificialServerWait); MockitoAnnotations.initMocks(this); startServer(); } @After public void tearDown() { stopServer(); } protected void waitForRequests(int expectedRequestCount) { int sleepMillis = 10; int waited = 0; AssertionError lastError = new AssertionError("Connections not established in time!"); while (waited < MAX_WAIT_REQUESTS_MILLIS) { try { assertThat(modbustRequestCaptor.getAllReturnValues().size(), is(equalTo(expectedRequestCount))); } catch (AssertionError e) { lastError = e; try { Thread.sleep(sleepMillis); waited += sleepMillis; } catch (InterruptedException e1) { throw new AssertionError("test interrupted"); } continue; } // OK! return; } // Requests not established in time throw lastError; } protected void waitForConnectionsReceived(int expectedConnections) { int sleepMillis = 10; int waited = 0; AssertionError lastError = new AssertionError("Connections not established in time!"); while (waited < MAX_WAIT_REQUESTS_MILLIS) { try { if (ServerType.TCP.equals(serverType)) { verify(tcpConnectionFactory, times(expectedConnections)).create(any(Socket.class)); } else if (ServerType.UDP.equals(serverType)) { // No-op // verify(udpTerminalFactory, times(expectedConnections)).create(any(InetAddress.class), // any(Integer.class)); } else if (ServerType.SERIAL.equals(serverType)) { // No-op } else { throw new NotImplementedException(); } } catch (AssertionError e) { lastError = e; try { Thread.sleep(sleepMillis); waited += sleepMillis; } catch (InterruptedException e1) { throw new AssertionError("test interrupted"); } continue; } // OK! return; } System.err.println("Connections not established in time!"); throw lastError; } private void startServer() throws UnknownHostException, InterruptedException { spi = new SimpleProcessImage(); ModbusCoupler.getReference().setProcessImage(spi); ModbusCoupler.getReference().setMaster(false); ModbusCoupler.getReference().setUnitID(SLAVE_UNIT_ID); if (ServerType.TCP.equals(serverType)) { startTCPServer(); } else if (ServerType.UDP.equals(serverType)) { startUDPServer(); } else if (ServerType.SERIAL.equals(serverType)) { startSerialServer(); } else { throw new NotImplementedException(); } } private void stopServer() { if (ServerType.TCP.equals(serverType)) { tcpListener.stop(); } else if (ServerType.UDP.equals(serverType)) { udpListener.stop(); System.err.println(udpModbusPort); } else if (ServerType.SERIAL.equals(serverType)) { try { serialServerThread.join(100); } catch (InterruptedException e) { e.printStackTrace(); } serialServerThread.interrupt(); } else { throw new NotImplementedException(); } } private void startUDPServer() throws UnknownHostException, InterruptedException { udpListener = new ModbusUDPListener(localAddress(), udpTerminalFactory); for (int portCandidate = 10000 + udpServerIndex.increment(); portCandidate < 20000; portCandidate++) { try { DatagramSocket socket = new DatagramSocket(portCandidate); socket.close(); udpListener.setPort(portCandidate); break; } catch (SocketException e) { continue; } } udpListener.start(); waitForUDPServerStartup(); Assert.assertNotSame(-1, udpModbusPort); Assert.assertNotSame(0, udpModbusPort); } private void waitForUDPServerStartup() throws InterruptedException { // Query server port. It seems to take time (probably due to thread starting) int sleep_millis = 5; int total_try_millis = 10000; // 10sec for (int tries = 0; tries < Math.max(1, total_try_millis / sleep_millis); tries++) { udpModbusPort = udpListener.getLocalPort(); if (udpModbusPort != -1) { break; } Thread.sleep(sleep_millis); } } private void startTCPServer() throws UnknownHostException, InterruptedException { // Serve single user at a time tcpListener = new ModbusTCPListener(SERVER_THREADS, localAddress(), tcpConnectionFactory); // Use any open port tcpListener.setPort(0); tcpListener.start(); // Query server port. It seems to take time (probably due to thread starting) waitForTCPServerStartup(); Assert.assertNotSame(-1, tcpModbusPort); Assert.assertNotSame(0, tcpModbusPort); } private void waitForTCPServerStartup() throws InterruptedException { int sleep_millis = 5; int total_try_millis = 10000; // 10sec for (int tries = 0; tries < Math.max(1, total_try_millis / sleep_millis); tries++) { tcpModbusPort = tcpListener.getLocalPort(); if (tcpModbusPort != -1) { break; } Thread.sleep(sleep_millis); } } private void startSerialServer() throws UnknownHostException, InterruptedException { serialServerThread.start(); Thread.sleep(1000); } /** * Transport factory that spies the created transport items */ public class SpyingModbusTCPTransportFactory extends ModbusTCPTransportFactory { @Override public ModbusTransport create(Socket socket) { ModbusTransport transport = spy(super.create(socket)); // Capture requests produced by our server transport try { doAnswer(modbustRequestCaptor).when(transport).readRequest(); } catch (ModbusIOException e) { throw new RuntimeException(e); } return transport; } } public class SpyingModbusUDPTransportFactory extends ModbusUDPTransportFactoryImpl { @Override public ModbusTransport create(UDPTerminal terminal) { ModbusTransport transport = spy(super.create(terminal)); // Capture requests produced by our server transport try { doAnswer(modbustRequestCaptor).when(transport).readRequest(); } catch (ModbusIOException e) { throw new RuntimeException(e); } return transport; } } public class TCPSlaveConnectionFactoryImpl implements TCPSlaveConnectionFactory { @Override public TCPSlaveConnection create(Socket socket) { return new TCPSlaveConnection(socket, new SpyingModbusTCPTransportFactory()); } } public class UDPSlaveTerminalFactoryImpl implements UDPSlaveTerminalFactory { @Override public UDPSlaveTerminal create(InetAddress interfac, int port) { UDPSlaveTerminal terminal = new UDPSlaveTerminal(interfac, new SpyingModbusUDPTransportFactory(), 1); terminal.setLocalPort(port); return terminal; } } public class SerialConnectionFactoryImpl implements SerialConnectionFactory { @Override public SerialConnection create(SerialParameters parameters) { SerialConnection serialConnection = new SerialConnection(parameters) { @Override public ModbusTransport getModbusTransport() { ModbusTransport transport = spy(super.getModbusTransport()); try { doAnswer(modbustRequestCaptor).when(transport).readRequest(); } catch (ModbusIOException e) { throw new RuntimeException(e); } return transport; } }; return serialConnection; } } }