Initialisation depot

java/test/jmri/jmrix/ipocs/protocol/packets/AcknowledgementPacketTest.java

@@ -0,0 +1,44 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class AcknowledgementPacketTest {
+  private final byte[] testPacket = { 0x00, 0x02 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(AcknowledgementPacket.IDENT, new AcknowledgementPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    AcknowledgementPacket pkt = new AcknowledgementPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x0002, pkt.getAckReason());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    AcknowledgementPacket pkt = new AcknowledgementPacket();
+    pkt.setAckReason((short)0x0002);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/AlarmPacketTest.java

@@ -0,0 +1,53 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqAlarmState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class AlarmPacketTest {
+  private final byte[] testPacket = { 0x01, 0x23, 0x45, RqAlarmState.Transient.value, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(AlarmPacket.IDENT, new AlarmPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    AlarmPacket pkt = new AlarmPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x0123, pkt.getAlarmCode());
+    assertEquals(0x45, pkt.getAlarmLevel());
+    assertEquals(RqAlarmState.Transient, pkt.getAlarmState());
+    assertEquals(1, pkt.getParameter1());
+    assertEquals(2, pkt.getParameter2());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    AlarmPacket pkt = new AlarmPacket();
+    pkt.setAlarmCode((short)0x0123);
+    pkt.setAlarmLevel((byte)0x45);
+    pkt.setAlarmState(RqAlarmState.Transient);
+    pkt.setParameter1(1);
+    pkt.setParameter2(2);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ApplicationDataPacketTest.java

@@ -0,0 +1,47 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ApplicationDataPacketTest {
+  private final byte[] testPacket = { 0x01, 0x23, 0x20, 0x00 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ApplicationDataPacket.IDENT, new ApplicationDataPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ApplicationDataPacket pkt = new ApplicationDataPacket();
+    pkt.setLength((byte)7);
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x0123, pkt.getxUser());
+    assertEquals(ByteBuffer.wrap(new byte[] { 0x20, 0x00 }), pkt.getData());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ApplicationDataPacket pkt = new ApplicationDataPacket();
+    pkt.setxUser((short)0x0123);
+    pkt.setData(ByteBuffer.wrap(new byte[] { 0x20, 0x00 }));
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ConnectionRequestPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ConnectionRequestPacketTest {
+  private final byte[] testPacket = { 0x01, 0x23, 0x20, 0x00 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ConnectionRequestPacket.IDENT, new ConnectionRequestPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ConnectionRequestPacket pkt = new ConnectionRequestPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x0123, pkt.getProtocolVersion());
+    assertEquals(" ", pkt.getSiteDataVersion());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ConnectionRequestPacket pkt = new ConnectionRequestPacket();
+    pkt.setProtocolVersion((short)0x0123);
+    pkt.setSiteDataVersion(" ");
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ConnectionResponsePacketTest.java

@@ -0,0 +1,43 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ConnectionResponsePacketTest {
+  private final byte[] testPacket = { 0x01, 0x23 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ConnectionResponsePacket.IDENT, new ConnectionResponsePacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ConnectionResponsePacket pkt = new ConnectionResponsePacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x0123, pkt.getProtocolVersion());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ConnectionResponsePacket pkt = new ConnectionResponsePacket();
+    pkt.setProtocolVersion((short)0x0123);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ControllerStatusPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqControllerState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ControllerStatusPacketTest {
+  private final byte[] testPacket = { RqControllerState.Restarting.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ControllerStatusPacket.IDENT, new ControllerStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ControllerStatusPacket pkt = new ControllerStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqControllerState.Restarting, pkt.getState());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ControllerStatusPacket pkt = new ControllerStatusPacket();
+    pkt.setState(RqControllerState.Restarting);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/DerailerStatusPacketTest.java

@@ -0,0 +1,49 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqDerailerState;
+import jmri.jmrix.ipocs.protocol.enums.RqReleaseState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class DerailerStatusPacketTest {
+  private final byte[] testPacket = { RqDerailerState.NonPassable.value, RqReleaseState.LocalControl.value, 0x01, 0x23 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(DerailerStatusPacket.IDENT, new DerailerStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    DerailerStatusPacket pkt = new DerailerStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqDerailerState.NonPassable, pkt.getState());
+    assertEquals(RqReleaseState.LocalControl, pkt.getReleaseState());
+    assertEquals(0x0123, pkt.getOperationTime());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    DerailerStatusPacket pkt = new DerailerStatusPacket();
+    pkt.setState(RqDerailerState.NonPassable);
+    pkt.setReleaseState(RqReleaseState.LocalControl);
+    pkt.setOperationTime((short)0x0123);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/DisconnectPacketTest.java

@@ -0,0 +1,44 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqDisconnect;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class DisconnectPacketTest {
+  private final byte[] testPacket = { RqDisconnect.UnitClosingDown.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(DisconnectPacket.IDENT, new DisconnectPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    DisconnectPacket pkt = new DisconnectPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqDisconnect.UnitClosingDown, pkt.getReason());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    DisconnectPacket pkt = new DisconnectPacket();
+    pkt.setReason(RqDisconnect.UnitClosingDown);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ElectricalPointsLockStatusPacketTest.java

@@ -0,0 +1,44 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqPointsLockState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ElectricalPointsLockStatusPacketTest {
+  private final byte[] testPacket = { RqPointsLockState.LockedRight.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ElectricalPointsLockStatusPacket.IDENT, new ElectricalPointsLockStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ElectricalPointsLockStatusPacket pkt = new ElectricalPointsLockStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqPointsLockState.LockedRight, pkt.getState());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ElectricalPointsLockStatusPacket pkt = new ElectricalPointsLockStatusPacket();
+    pkt.setState(RqPointsLockState.LockedRight);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/InputStatusPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqInputState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class InputStatusPacketTest {
+  private final byte[] testPacket = { RqInputState.On.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(InputStatusPacket.IDENT, new InputStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    InputStatusPacket pkt = new InputStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqInputState.On, pkt.getState());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    InputStatusPacket pkt = new InputStatusPacket();
+    pkt.setState(RqInputState.On);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/LevelCrossingStatusPacketTest.java

@@ -0,0 +1,50 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqLevelCrossingState;
+import jmri.jmrix.ipocs.protocol.enums.RqReleaseState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class LevelCrossingStatusPacketTest {
+  private final byte[] testPacket = { RqLevelCrossingState.Opening.value, RqReleaseState.LocalControl.value, 0x01, 0x23 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(LevelCrossingStatusPacket.IDENT, new LevelCrossingStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    LevelCrossingStatusPacket pkt = new LevelCrossingStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqLevelCrossingState.Opening, pkt.getState());
+    assertEquals(RqReleaseState.LocalControl, pkt.getReleaseState());
+    assertEquals(0x0123, pkt.getOperationTime());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    LevelCrossingStatusPacket pkt = new LevelCrossingStatusPacket();
+    pkt.setState(RqLevelCrossingState.Opening);
+    pkt.setReleaseState(RqReleaseState.LocalControl);
+    pkt.setOperationTime((short)0x0123);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/LocalReleasePacketTest.java

@@ -0,0 +1,44 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqReleaseCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class LocalReleasePacketTest {
+  private final byte[] testPacket = { RqReleaseCommand.LocalControl.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(LocalReleasePacket.IDENT, new LocalReleasePacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    LocalReleasePacket pkt = new LocalReleasePacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqReleaseCommand.LocalControl, pkt.getCommand());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    LocalReleasePacket pkt = new LocalReleasePacket();
+    pkt.setCommand(RqReleaseCommand.LocalControl);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+}

java/test/jmri/jmrix/ipocs/protocol/packets/OutputStatusPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqOutputState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class OutputStatusPacketTest {
+  private final byte[] testPacket = { RqOutputState.On.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(OutputStatusPacket.IDENT, new OutputStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    OutputStatusPacket pkt = new OutputStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqOutputState.On, pkt.getState());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    OutputStatusPacket pkt = new OutputStatusPacket();
+    pkt.setState(RqOutputState.On);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/PacketTest.java

@@ -0,0 +1,68 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.nio.ByteBuffer;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class PacketTest {
+
+    private Packet pkt = null;
+    private final byte[] testPacket = { 0x20, 0x03, 0x12 };
+
+  @Test
+  public void ackTest() {
+    byte[] bytes = new byte[1];
+    JUnitUtil.getRandom().nextBytes(bytes);
+    pkt.setAck(bytes[0]);
+    assertEquals(bytes[0], pkt.getAck());
+  }
+
+  @Test
+  public void parseTest() {
+    // This test is not a really good one - it relies on the actual ServiceLoader.
+    // Could be solved by using PowerMockito:
+    // stackoverflow.com/questions/21105403/mocking-static-methods-with-mockito
+    byte[] successPacket = { ResetControllerPacket.IDENT, 0x03, 0x00 };
+    assertNotNull(Packet.parse(ByteBuffer.wrap(successPacket)));
+    //assertNull(Packet.parse(ByteBuffer.wrap(testPacket))); // throws IO Exception, packet=null
+    //jmri.util.JUnitAppender.suppressErrorMessage("No packet found for identifier 32"); // better to fix method (or test input)
+  }
+
+  @Test
+  public void serializeTest() {
+    pkt.setAck((byte)0x12);
+    assertEquals(ByteBuffer.wrap(testPacket), pkt.serialize());
+    assertEquals(0x03, pkt.getLength());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+        pkt = new Packet() {
+            @Override
+            public byte getId() {
+                return (char)0x20;
+            }
+
+            @Override
+            protected void parseSpecific(ByteBuffer buffer) {
+            }
+
+            @Override
+            protected byte[] serializeSpecific() {
+                return new byte[0];
+            }
+        };
+    }
+
+    @AfterEach
+    public void tearDown() {
+        pkt = null;
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/PointsStatusPacketTest.java

@@ -0,0 +1,50 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqPointsState;
+import jmri.jmrix.ipocs.protocol.enums.RqReleaseState;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class PointsStatusPacketTest {
+  private final byte[] testPacket = { RqPointsState.Left.value, RqReleaseState.LocalControl.value, 0x01, 0x23 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(PointsStatusPacket.IDENT, new PointsStatusPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    PointsStatusPacket pkt = new PointsStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqPointsState.Left, pkt.getState());
+    assertEquals(RqReleaseState.LocalControl, pkt.getReleaseState());
+    assertEquals(0x0123, pkt.getOperationTime());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    PointsStatusPacket pkt = new PointsStatusPacket();
+    pkt.setState(RqPointsState.Left);
+    pkt.setReleaseState(RqReleaseState.LocalControl);
+    pkt.setOperationTime((short)0x0123);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/RequestStatusPacketTest.java

@@ -0,0 +1,42 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class RequestStatusPacketTest {
+  private final byte[] testPacket = { };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(RequestStatusPacket.IDENT, new RequestStatusPacket().getId()); 
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    RequestStatusPacket pkt = new RequestStatusPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    RequestStatusPacket pkt = new RequestStatusPacket();
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ResetControllerPacketTest.java

@@ -0,0 +1,42 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ResetControllerPacketTest {
+  private final byte[] testPacket = { };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ResetControllerPacket.IDENT, new ResetControllerPacket().getId()); 
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ResetControllerPacket pkt = new ResetControllerPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ResetControllerPacket pkt = new ResetControllerPacket();
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SetDerailerPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqDerailerCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class SetDerailerPacketTest {
+  private final byte[] testPacket = { RqDerailerCommand.Passable.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(SetDerailerPacket.IDENT, new SetDerailerPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    SetDerailerPacket pkt = new SetDerailerPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqDerailerCommand.Passable, pkt.getCommand());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    SetDerailerPacket pkt = new SetDerailerPacket();
+    pkt.setCommand(RqDerailerCommand.Passable);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SetElectricalPointsLockPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqPointsLockCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class SetElectricalPointsLockPacketTest {
+  private final byte[] testPacket = { RqPointsLockCommand.Lock.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(SetElectricalPointsLockPacket.IDENT, new SetElectricalPointsLockPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    SetElectricalPointsLockPacket pkt = new SetElectricalPointsLockPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqPointsLockCommand.Lock, pkt.getCommand());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    SetElectricalPointsLockPacket pkt = new SetElectricalPointsLockPacket();
+    pkt.setCommand(RqPointsLockCommand.Lock);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SetLevelCrossingPacketTest.java

@@ -0,0 +1,49 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqLevelCrossingCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class SetLevelCrossingPacketTest {
+  private final byte[] testPacket = {RqLevelCrossingCommand.Close.value, 0x00, 0x10, 0x01};
+
+  @Test
+  public void getIdTest() {
+    assertEquals(SetLevelCrossingPacket.IDENT, new SetLevelCrossingPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    final SetLevelCrossingPacket pkt = new SetLevelCrossingPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqLevelCrossingCommand.Close, pkt.getCommand());
+    assertEquals(0x0010, pkt.getDelay());
+    assertEquals(0x01, pkt.getTrack());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    final SetLevelCrossingPacket pkt = new SetLevelCrossingPacket();
+    pkt.setCommand(RqLevelCrossingCommand.Close);
+    pkt.setDelay((short)0x0010);
+    pkt.setTrack((byte)0x01);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SetOutputPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqOutputCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class SetOutputPacketTest {
+  private final byte[] testPacket = { RqOutputCommand.Off.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(SetOutputPacket.IDENT, new SetOutputPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    SetOutputPacket pkt = new SetOutputPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqOutputCommand.Off, pkt.getCommand());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    SetOutputPacket pkt = new SetOutputPacket();
+    pkt.setCommand(RqOutputCommand.Off);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SignOfLifePacketTest.java

@@ -0,0 +1,26 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import jmri.util.JUnitUtil;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.*;
+
+public class SignOfLifePacketTest {
+
+    @Test
+    public void getIdTest() {
+        assertEquals(SignOfLifePacket.IDENT, new SignOfLifePacket().getId()); 
+    }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/SignOfLifeTimerPacketTest.java

@@ -0,0 +1,44 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class SignOfLifeTimerPacketTest {
+  private final byte[] testPacket = { 0x10, 0x11 };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(SignOfLifeTimerPacket.IDENT, new SignOfLifeTimerPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    SignOfLifeTimerPacket pkt = new SignOfLifeTimerPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(0x1011, pkt.getInterval());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    SignOfLifeTimerPacket pkt = new SignOfLifeTimerPacket();
+    pkt.setInterval((short)0x1011);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}

java/test/jmri/jmrix/ipocs/protocol/packets/ThrowPointsPacketTest.java

@@ -0,0 +1,45 @@
+package jmri.jmrix.ipocs.protocol.packets;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.ByteBuffer;
+
+import jmri.jmrix.ipocs.protocol.enums.RqPointsCommand;
+import jmri.util.JUnitUtil;
+
+import org.junit.jupiter.api.*;
+
+public class ThrowPointsPacketTest {
+  private final byte[] testPacket = { RqPointsCommand.Left.value };
+
+  @Test
+  public void getIdTest() {
+    assertEquals(ThrowPointsPacket.IDENT, new ThrowPointsPacket().getId());
+  }
+
+  @Test
+  public void parseSpecificTest() {
+    ThrowPointsPacket pkt = new ThrowPointsPacket();
+    pkt.parseSpecific(ByteBuffer.wrap(testPacket));
+    assertEquals(RqPointsCommand.Left, pkt.getCommand());
+  }
+
+  @Test
+  public void serializeSpecificTest() {
+    ThrowPointsPacket pkt = new ThrowPointsPacket();
+    pkt.setCommand(RqPointsCommand.Left);
+    assertArrayEquals(testPacket, pkt.serializeSpecific());
+  }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}