Serge NOEL
1994 lines
76 KiB
Java
1994 lines
76 KiB
Java
package jmri;
|
|
|
|
import jmri.util.JUnitAppender;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
|
|
/**
|
|
* Unit tests for NmraPacket.
|
|
* @author Bob Jacobsen
|
|
*/
|
|
public class NmraPacketTest {
|
|
|
|
// output values for some of these tests were provided by Bob Scheffler
|
|
// create an accessory decoder packet
|
|
@Test
|
|
public void testAccDecoderPacket1() {
|
|
// test fixed bits
|
|
byte[] ba = NmraPacket.accDecoderPkt(1, 0, 0);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xF0, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x71, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket2() {
|
|
// test C bit
|
|
byte[] ba = NmraPacket.accDecoderPkt(1, 1, 0);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xF8, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x79, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket3() {
|
|
// test D bits
|
|
byte[] ba = NmraPacket.accDecoderPkt(1, 0, 7);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xF7, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x76, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket4() {
|
|
// test short part of address
|
|
byte[] ba = NmraPacket.accDecoderPkt(3, 0, 0);
|
|
assertEquals( 0x83, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xF0, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x73, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket5() {
|
|
// test top part of address
|
|
byte[] ba = NmraPacket.accDecoderPkt(128, 0, 0);
|
|
assertEquals( 0x80, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xD0, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x50, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket6() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.accDecoderPkt(33, 1, 5);
|
|
assertEquals( 0xA1, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xFD, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x5C, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket7() {
|
|
// address 256
|
|
byte[] ba = NmraPacket.accDecoderPkt(256, true);
|
|
assertEquals( 0x80, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xEF, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x6F, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket8() {
|
|
// address 257
|
|
byte[] ba = NmraPacket.accDecoderPkt(257, true);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xE9, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x68, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket9() {
|
|
// address 512
|
|
byte[] ba = NmraPacket.accDecoderPkt(512, true);
|
|
assertEquals( 0x80, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDF, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x5F, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket10() {
|
|
// address 513
|
|
byte[] ba = NmraPacket.accDecoderPkt(513, true);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xD9, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x58, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket11() {
|
|
// address 1024
|
|
byte[] ba = NmraPacket.accDecoderPkt(1024, true);
|
|
assertEquals( 0x80, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xBF, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x3F, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket12() {
|
|
// address 1025
|
|
byte[] ba = NmraPacket.accDecoderPkt(1025, true);
|
|
assertEquals( 0x81, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xB9, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x38, ba[2] & 0xFF, "third byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPacket13() {
|
|
// invalid address (0)
|
|
int addr = 0;
|
|
// expect this to throw exception
|
|
Exception ex = assertThrows( IllegalArgumentException.class, () ->
|
|
NmraPacket.accDecoderPkt(addr, 0, 0), "Expected exception");
|
|
assertNotNull(ex);
|
|
jmri.util.JUnitAppender.assertErrorMessage("invalid address " + addr);
|
|
}
|
|
|
|
@Test
|
|
public void testOpsModeLong() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.opsCvWriteByte(2065, true, 21, 75);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x14, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0x4B, ba[4] & 0xFF, "fifth byte ");
|
|
assertEquals( 0x6A, ba[5] & 0xFF, "sixth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testOpsModeShort() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.opsCvWriteByte(65, false, 21, 75);
|
|
assertEquals( 0x41, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xEC, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x14, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x4B, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xF2, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAnalog1() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.analogControl(60, false, 1, 00);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x3D, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x01, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0x3C ^ 0x3D ^ 0x01, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testAnalog2() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.analogControl(60, false, 1, 12);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x3D, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x01, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x0C, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0x3C ^ 0x3D ^ 0x01 ^ 0x0C, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF13F20A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function13Through20Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDE, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xDE ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF13F20B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function13Through20Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xDE, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xDE ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF21F28A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function21Through28Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDF, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xDF ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF21F28B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function21Through28Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xDF, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xDF ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF29F36A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function29Through36Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xD8, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xD8 ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF29F36B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function29Through36Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xD8, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xD8 ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF37F44A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function37Through44Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xD9, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xD9 ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF37F44B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function37Through44Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xD9, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xD9 ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF45F52A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function45Through52Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDA, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xDA ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF45F52B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function45Through52Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xDA, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xDA ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF53F60A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function53Through60Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDB, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xDB ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF53F60B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function53Through60Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xDB, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xDB ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF61F68A() {
|
|
// "typical packet" test, short address
|
|
byte[] ba = NmraPacket.function61Through68Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0xDC, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x55, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0xDC ^ 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testF61F68B() {
|
|
// "typical packet" test, long address
|
|
byte[] ba = NmraPacket.function61Through68Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0xDC, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x55, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0xDC ^ 0x55, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testConsist1() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.consistControl(60, false, 1, true);
|
|
assertEquals( 0x3C, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x12, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x01, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x3C ^ 0x12 ^ 0x01, ba[3] & 0xFF, "fourth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testConsist2() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.consistControl(2065, true, 12, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x13, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x0C, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0x13 ^ 0x0C, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testConsist3() {
|
|
// "typical packet" test
|
|
byte[] ba = NmraPacket.consistControl(2065, true, 0, false);
|
|
assertEquals( 0xC8, ba[0] & 0xFF, "first byte ");
|
|
assertEquals( 0x11, ba[1] & 0xFF, "second byte ");
|
|
assertEquals( 0x13, ba[2] & 0xFF, "third byte ");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "fourth byte ");
|
|
assertEquals( 0xC8 ^ 0x11 ^ 0x13 ^ 0x00, ba[4] & 0xFF, "fifth byte ");
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktOK() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(123, 12);
|
|
assertTrue(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseConsist() {
|
|
byte[] ba = NmraPacket.consistControl(2065, true, 0, false);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseFunction() {
|
|
byte[] ba = NmraPacket.function21Through28Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseAnalog() {
|
|
byte[] ba = NmraPacket.analogControl(60, false, 1, 12);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseOpsWrite() {
|
|
byte[] ba = NmraPacket.opsCvWriteByte(65, false, 21, 75);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseAccDecoder() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(257, true);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseAccDecoderPktOpsMode() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(257, 33, 5);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccSignalDecoderPktFalseAccDecoderPktOpsModeLegacy() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(1843, 384, 255);
|
|
assertFalse(NmraPacket.isAccSignalDecoderPkt(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseSignalDecoderPkt() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(123, 12);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseConsist() {
|
|
byte[] ba = NmraPacket.consistControl(2065, true, 0, false);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseFunction() {
|
|
byte[] ba = NmraPacket.function21Through28Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseAnalog() {
|
|
byte[] ba = NmraPacket.analogControl(60, false, 1, 12);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseOpsWrite() {
|
|
byte[] ba = NmraPacket.opsCvWriteByte(65, false, 21, 75);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseAccDecoder() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(257, true);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeOK() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(257, 33, 5);
|
|
assertTrue(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeFalseAccDecoderPktOpsModeLegacy() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(1843, 384, 255);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsMode(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseSignalDecoderPkt() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(123, 12);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseConsist() {
|
|
byte[] ba = NmraPacket.consistControl(2065, true, 0, false);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseFunction() {
|
|
byte[] ba = NmraPacket.function21Through28Packet(2065, true, true, false, true, false, true, false, true, false);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseAnalog() {
|
|
byte[] ba = NmraPacket.analogControl(60, false, 1, 12);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseOpsWrite() {
|
|
byte[] ba = NmraPacket.opsCvWriteByte(65, false, 21, 75);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseAccDecoder() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(257, true);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyFalseAccDecoderPktOpsMode() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(257, 33, 5);
|
|
assertFalse(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testIsAccDecoderPktOpsModeLegacyOK() {
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(1843, 384, 255);
|
|
assertTrue(NmraPacket.isAccDecoderPktOpsModeLegacy(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr1() {
|
|
int addr = 1;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr2() {
|
|
int addr = 2;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr4() {
|
|
int addr = 4;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr8() {
|
|
int addr = 8;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr16() {
|
|
int addr = 16;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr32() {
|
|
int addr = 32;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr64() {
|
|
int addr = 64;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr128() {
|
|
int addr = 128;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr256() {
|
|
int addr = 256;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr512() {
|
|
int addr = 512;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr1024() {
|
|
int addr = 1024;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testGetAccSignalDecoderPktAddr2044() { // max valid value
|
|
int addr = 2044;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(addr, 12);
|
|
assertEquals(addr, NmraPacket.getAccSignalDecoderPktAddress(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsModeLegacy1() {
|
|
int address = 1;
|
|
int cv = 29;
|
|
int data = 136;
|
|
byte[] ba = NmraPacket.accDecPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x7C, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x1C, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x88, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x69, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsMode1() {
|
|
int address = 1;
|
|
int cv = 29;
|
|
int data = 136;
|
|
byte[] ba = NmraPacket.accDecPktOpsMode(address, cv, data);
|
|
|
|
// the following values based on NCE Power Pro output adjusted for CDDD=0000
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xF0, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x1C, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x88, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x09, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsModeLegacy2() {
|
|
int address = 2;
|
|
int cv = 41;
|
|
int data = 24;
|
|
byte[] ba = NmraPacket.accDecPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x7C, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x28, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x18, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xCE, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsMode2() {
|
|
int address = 2;
|
|
int cv = 41;
|
|
int data = 24;
|
|
byte[] ba = NmraPacket.accDecPktOpsMode(address, cv, data);
|
|
|
|
// the following values based on NCE Power Pro output adjusted for CDDD=0000
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xF0, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x28, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x18, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xAE, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsModeLegacy510() {
|
|
int address = 510;
|
|
int cv = 892;
|
|
int data = 135;
|
|
byte[] ba = NmraPacket.accDecPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x0F, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x7B, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x87, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x4D, ba[4] & 0xFF, "byte 4");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsMode510() {
|
|
int address = 510;
|
|
int cv = 892;
|
|
int data = 135;
|
|
byte[] ba = NmraPacket.accDecPktOpsMode(address, cv, data);
|
|
|
|
// the following values based on NCE Power Pro output adjusted for CDDD=0000
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x80, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x7B, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x87, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x2D, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsModeLegacy511() {
|
|
int address = 511;
|
|
int cv = 275;
|
|
int data = 198;
|
|
byte[] ba = NmraPacket.accDecPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x0D, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x12, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xC6, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x66, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecPktOpsMode511() {
|
|
int address = 511;
|
|
int cv = 275;
|
|
int data = 198;
|
|
byte[] ba = NmraPacket.accDecPktOpsMode(address, cv, data);
|
|
|
|
// the following values based on NCE Power Pro output adjusted for CDDD=0000
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x80, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x12, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xC6, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x6, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecPktOpsModeAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy1() {
|
|
int address = 1;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x7D, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x7F, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFF, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x7C, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode1() {
|
|
int address = 1;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xF9, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x7F, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xFF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x15, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy4() {
|
|
int address = 4;
|
|
int cv = 56;
|
|
int data = 0;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x7C, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x37, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xCA, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode4() {
|
|
int address = 4;
|
|
int cv = 56;
|
|
int data = 0;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xFF, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x37, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x00, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xA5, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy5() {
|
|
int address = 5;
|
|
int cv = 1;
|
|
int data = 30;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x7C, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x00, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x1E, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xE0, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode5() {
|
|
int address = 5;
|
|
int cv = 1;
|
|
int data = 30;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xF9, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x1E, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x89, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode252() {
|
|
int address = 252;
|
|
int cv = 999;
|
|
int data = 179;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xFF, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE6, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xB3, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xFA, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode253() {
|
|
int address = 253;
|
|
int cv = 1;
|
|
int data = 241;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xE9, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xF1, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x74, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode256() {
|
|
int address = 256;
|
|
int cv = 55;
|
|
int data = 127;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xEF, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x7F, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xCA, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode257() {
|
|
int address = 257;
|
|
int cv = 55;
|
|
int data = 99;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0xE9, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x63, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xD1, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy2037() {
|
|
int address = 2037;
|
|
int cv = 556;
|
|
int data = 175;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x0E, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x2B, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xAF, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x34, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode2037() {
|
|
int address = 2037;
|
|
int cv = 556;
|
|
int data = 175;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x89, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEE, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x2B, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xAF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x5D, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy2040() {
|
|
int address = 2040;
|
|
int cv = 771;
|
|
int data = 102;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x0F, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x02, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x66, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xD5, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode2040() {
|
|
int address = 2040;
|
|
int cv = 771;
|
|
int data = 102;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x8F, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x02, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x66, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xBA, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsModeLegacy2044() {
|
|
int address = 2044;
|
|
int cv = 1024;
|
|
int data = 151;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsModeLegacy(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 5, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x0F, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xFF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x97, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xD8, ba[4] & 0xFF, "byte 4");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsModeLegacy(ba), "verify packet type");
|
|
assertEquals( decAddr(address), NmraPacket.getAccDecoderPktOpsModeLegacyAddress(ba), "reverse lookup of decoder address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccDecoderPktOpsMode2044() {
|
|
int address = 2044;
|
|
int cv = 1024;
|
|
int data = 151;
|
|
byte[] ba = NmraPacket.accDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x8F, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFF, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x97, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xB7, ba[5] & 0xFF, "byte 5");
|
|
|
|
// check packet type and reverse address lookup
|
|
assertTrue( NmraPacket.isAccDecoderPktOpsMode(ba), "verify packet type");
|
|
assertEquals( address, NmraPacket.getAccDecoderPktOpsModeAddress(ba), "reverse lookup of address");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode1() {
|
|
int address = 1;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x7F, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xFF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x9D, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode4() {
|
|
int address = 4;
|
|
int cv = 56;
|
|
int data = 0;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x37, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x00, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x2D, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode5() {
|
|
int address = 5;
|
|
int cv = 1;
|
|
int data = 30;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x1E, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x01, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode252() {
|
|
int address = 252;
|
|
int cv = 999;
|
|
int data = 179;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE6, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xB3, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x72, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode253() {
|
|
int address = 253;
|
|
int cv = 1;
|
|
int data = 241;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x61, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xF1, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xFC, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode256() {
|
|
int address = 256;
|
|
int cv = 55;
|
|
int data = 127;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x67, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x7F, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x42, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode257() {
|
|
int address = 257;
|
|
int cv = 55;
|
|
int data = 99;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x61, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x63, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x59, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode2037() {
|
|
int address = 2037;
|
|
int cv = 556;
|
|
int data = 175;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x01, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEE, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x2B, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xAF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xD5, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode2040() {
|
|
int address = 2040;
|
|
int cv = 771;
|
|
int data = 102;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x07, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x02, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x66, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x32, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPktOpsMode2044() {
|
|
int address = 2044;
|
|
int cv = 1024;
|
|
int data = 151;
|
|
byte[] ba = NmraPacket.accSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x07, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFF, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x97, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x3F, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt1Aspect23() {
|
|
int address = 1;
|
|
int aspect = 23;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x17, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE7, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt2Aspect5() {
|
|
int address = 2;
|
|
int aspect = 5;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x73, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x05, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xF7, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt3Aspect9() {
|
|
int address = 3;
|
|
int aspect = 9;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x75, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x09, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFD, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt4Aspect11() {
|
|
int address = 4;
|
|
int aspect = 11;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x0B, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFD, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt5Aspect15() {
|
|
int address = 5;
|
|
int aspect = 15;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x0F, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFC, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt6Aspect28() {
|
|
int address = 6;
|
|
int aspect = 28;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x73, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x1C, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xED, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt7Aspect10() {
|
|
int address = 7;
|
|
int aspect = 10;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x75, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x0A, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFD, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt8Aspect11() {
|
|
int address = 8;
|
|
int aspect = 11;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x0B, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xFE, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt252Aspect13() {
|
|
int address = 252;
|
|
int aspect = 13;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x0D, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xC5, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt253Aspect19() {
|
|
int address = 253;
|
|
int aspect = 19;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x61, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x13, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xF2, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt254Aspect2() {
|
|
int address = 254;
|
|
int aspect = 2;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x63, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x02, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE1, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt255Aspect3() {
|
|
int address = 255;
|
|
int aspect = 3;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x65, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x3, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE6, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt256Aspect7() {
|
|
int address = 256;
|
|
int aspect = 7;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x67, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x07, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE0, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt2044Aspect0() {
|
|
int address = 2044;
|
|
int aspect = 0;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x07, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x00, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xB8, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAccSignalDecoderPkt2044Aspect31() {
|
|
int address = 2044;
|
|
int aspect = 31;
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(address, aspect);
|
|
|
|
// the following values validated against NCE Power Pro output
|
|
assertEquals( 4, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x07, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0x1F, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xA7, ba[3] & 0xFF, "byte 3");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode1() {
|
|
int address = 1;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x7F, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xFF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x9C, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode4() {
|
|
int address = 4;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 0");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 1");
|
|
assertEquals( 0x7F, ba[3] & 0xFF, "byte 2");
|
|
assertEquals( 0xFF, ba[4] & 0xFF, "byte 3");
|
|
assertEquals( 0x9A, ba[5] & 0xFF, "byte 4");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode5() {
|
|
int address = 5;
|
|
int cv = 384;
|
|
int data = 255;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xED, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x7F, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xFF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x9D, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode8() {
|
|
int address = 8;
|
|
int cv = 56;
|
|
int data = 0;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF,"byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF,"byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF,"byte 2");
|
|
assertEquals( 0x37, ba[3] & 0xFF,"byte 3");
|
|
assertEquals( 0x00, ba[4] & 0xFF,"byte 4");
|
|
assertEquals( 0x2D, ba[5] & 0xFF,"byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode9() {
|
|
int address = 9;
|
|
int cv = 1;
|
|
int data = 30;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x82, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x71, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x1E, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x01, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode256() {
|
|
int address = 256;
|
|
int cv = 999;
|
|
int data = 179;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBF, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x77, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0xE6, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xB3, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x72, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode257() {
|
|
int address = 257;
|
|
int cv = 1;
|
|
int data = 241;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x61, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x00, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xF1, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xFC, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode260() {
|
|
int address = 260;
|
|
int cv = 55;
|
|
int data = 127;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x80, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x67, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x7F, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x42, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode261() {
|
|
int address = 261;
|
|
int cv = 55;
|
|
int data = 99;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0x81, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x61, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEC, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x36, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x63, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x59, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode2041() {
|
|
int address = 2041;
|
|
int cv = 556;
|
|
int data = 175;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x01, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEE, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x2B, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0xAF, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0xD5, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testAltAccSignalDecoderPktOpsMode2044() {
|
|
int address = 2044;
|
|
int cv = 771;
|
|
int data = 102;
|
|
byte[] ba = NmraPacket.altAccSignalDecoderPktOpsMode(address, cv, data);
|
|
|
|
assertEquals( 6, ba.length, "length");
|
|
assertEquals( 0xBE, ba[0] & 0xFF, "byte 0");
|
|
assertEquals( 0x07, ba[1] & 0xFF, "byte 1");
|
|
assertEquals( 0xEF, ba[2] & 0xFF, "byte 2");
|
|
assertEquals( 0x02, ba[3] & 0xFF, "byte 3");
|
|
assertEquals( 0x66, ba[4] & 0xFF, "byte 4");
|
|
assertEquals( 0x32, ba[5] & 0xFF, "byte 5");
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressTypeAcc() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(123, 12);
|
|
assertEquals( NmraPacket.DccAddressType.ACCESSORY_ADDRESS, NmraPacket.extractAddressType(ba), "Accessory");
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressTypeShort() {
|
|
byte[] bs = NmraPacket.function13Through20Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( NmraPacket.DccAddressType.LOCO_SHORT_ADDRESS, NmraPacket.extractAddressType(bs), "Short Loco");
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressTypeLong() {
|
|
byte[] bl = NmraPacket.function13Through20Packet(2060, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( NmraPacket.DccAddressType.LOCO_LONG_ADDRESS, NmraPacket.extractAddressType(bl), "Long Loco");
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal1() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(1, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(1, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal2() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(2, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(2, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal4() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(4, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(4, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal8() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(8, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(8, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal16() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(16, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(16, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal32() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(32, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(32, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal64() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(64, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(64, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal128() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(128, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(128, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAccSignal256() {
|
|
byte[] ba = NmraPacket.accSignalDecoderPkt(256, 12);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(256, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc1() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(1, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(1, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc2() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(2, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(2, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc4() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(4, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(4, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc8() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(8, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(8, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc16() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(16, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(16, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc32() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(32, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(32, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc64() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(64, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(64, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc128() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(128, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(128, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc256() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(256, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(256, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberAcc512() {
|
|
byte[] ba = NmraPacket.accDecoderPkt(512, true);
|
|
NmraPacket.extractAddressNumber(ba);
|
|
assertEquals(512, NmraPacket.extractAddressNumber(ba));
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberShort() {
|
|
byte[] bs = NmraPacket.function13Through20Packet(60, false, true, false, true, false, true, false, true, false);
|
|
assertEquals( 60, NmraPacket.extractAddressNumber(bs), "Short Loco");
|
|
}
|
|
|
|
@Test
|
|
public void testExtractAddressNumberLong() {
|
|
byte[] bl = NmraPacket.function13Through20Packet(2060, true, true, false, true, false, true, false, true, false);
|
|
assertEquals( 2060, NmraPacket.extractAddressNumber(bl), "Long Loco");
|
|
}
|
|
|
|
/**
|
|
* Test the 28 speed step forward throttle Note that this has not been
|
|
* independently verified
|
|
*/
|
|
@Test
|
|
public void testSpeedStep28PacketOld() {
|
|
int address = 100;
|
|
// results for speed steps 0-28 when forward
|
|
byte[][] speeds = {
|
|
{-64, 100, 96, -60}, // 0
|
|
{-64, 100, 113, -43}, // 1
|
|
{-64, 100, 98, -58}, // 2
|
|
{-64, 100, 114, -42}, // 3
|
|
{-64, 100, 99, -57}, // 4
|
|
{-64, 100, 115, -41}, // 5
|
|
{-64, 100, 100, -64}, // 6
|
|
{-64, 100, 116, -48}, // 7
|
|
{-64, 100, 101, -63}, // 8
|
|
{-64, 100, 117, -47}, // 9
|
|
{-64, 100, 102, -62}, // 10
|
|
{-64, 100, 118, -46}, // 11
|
|
{-64, 100, 103, -61}, // 12
|
|
{-64, 100, 119, -45}, // 13
|
|
{-64, 100, 104, -52}, // 14
|
|
{-64, 100, 120, -36}, // 15
|
|
{-64, 100, 105, -51}, // 16
|
|
{-64, 100, 121, -35}, // 17
|
|
{-64, 100, 106, -50}, // 18
|
|
{-64, 100, 122, -34}, // 19
|
|
{-64, 100, 107, -49}, // 20
|
|
{-64, 100, 123, -33}, // 21
|
|
{-64, 100, 108, -56}, // 22
|
|
{-64, 100, 124, -40}, // 23
|
|
{-64, 100, 109, -55}, // 24
|
|
{-64, 100, 125, -39}, // 25
|
|
{-64, 100, 110, -54}, // 26
|
|
{-64, 100, 126, -38}, // 27
|
|
{-64, 100, 111, -53} // 28
|
|
};
|
|
for (int speed = 0; speed < 29; speed++) {
|
|
byte[] packet = NmraPacket.speedStep28Packet(address, true, speed, true);
|
|
assertNotNull(packet);
|
|
assertArrayEquals( speeds[speed], packet, "Speed step " + speed);
|
|
}
|
|
// invalid inputs should result in null output
|
|
assertNull( NmraPacket.speedStep28Packet(address, true, -1, true), "Speed step -1");
|
|
JUnitAppender.assertErrorMessage("invalid speed -1");
|
|
assertNull( NmraPacket.speedStep28Packet(address, true, 29, true), "Speed step 29");
|
|
JUnitAppender.assertErrorMessage("invalid speed 29");
|
|
}
|
|
|
|
/**
|
|
* Test the 28 speed step forward throttle Note that this has not been
|
|
* independently verified
|
|
*/
|
|
@Test
|
|
public void testSpeedStep28Packet() {
|
|
int address = 100;
|
|
// results for speed steps 0-31 when forward
|
|
byte[][] forward = {
|
|
{-64, 100, 96, -60}, // 0
|
|
{-64, 100, 112, -44}, // 1
|
|
{-64, 100, 97, -59}, // 2
|
|
{-64, 100, 113, -43}, // 3
|
|
{-64, 100, 98, -58}, // 4
|
|
{-64, 100, 114, -42}, // 5
|
|
{-64, 100, 99, -57}, // 6
|
|
{-64, 100, 115, -41}, // 7
|
|
{-64, 100, 100, -64}, // 8
|
|
{-64, 100, 116, -48}, // 9
|
|
{-64, 100, 101, -63}, // 10
|
|
{-64, 100, 117, -47}, // 11
|
|
{-64, 100, 102, -62}, // 12
|
|
{-64, 100, 118, -46}, // 13
|
|
{-64, 100, 103, -61}, // 14
|
|
{-64, 100, 119, -45}, // 15
|
|
{-64, 100, 104, -52}, // 16
|
|
{-64, 100, 120, -36}, // 17
|
|
{-64, 100, 105, -51}, // 18
|
|
{-64, 100, 121, -35}, // 19
|
|
{-64, 100, 106, -50}, // 20
|
|
{-64, 100, 122, -34}, // 21
|
|
{-64, 100, 107, -49}, // 22
|
|
{-64, 100, 123, -33}, // 23
|
|
{-64, 100, 108, -56}, // 24
|
|
{-64, 100, 124, -40}, // 25
|
|
{-64, 100, 109, -55}, // 26
|
|
{-64, 100, 125, -39}, // 27
|
|
{-64, 100, 110, -54}, // 28
|
|
{-64, 100, 126, -38}, // 29
|
|
{-64, 100, 111, -53}, // 30
|
|
{-64, 100, 127, -37} // 31
|
|
};
|
|
for (int speed = 0; speed < 32; speed++) {
|
|
byte[] packet = NmraPacket.speedStep28Packet(true, address, true, speed, true);
|
|
assertNotNull(packet);
|
|
assertArrayEquals( forward[speed], packet, "Speed step " + speed);
|
|
}
|
|
// results for speed steps 0-31 when reversed
|
|
byte[][] reverse = {
|
|
{-64, 100, 64, -28}, // 0
|
|
{-64, 100, 80, -12}, // 1
|
|
{-64, 100, 65, -27}, // 2
|
|
{-64, 100, 81, -11}, // 3
|
|
{-64, 100, 66, -26}, // 4
|
|
{-64, 100, 82, -10}, // 5
|
|
{-64, 100, 67, -25}, // 6
|
|
{-64, 100, 83, -9}, // 7
|
|
{-64, 100, 68, -32}, // 8
|
|
{-64, 100, 84, -16}, // 9
|
|
{-64, 100, 69, -31}, // 10
|
|
{-64, 100, 85, -15}, // 11
|
|
{-64, 100, 70, -30}, // 12
|
|
{-64, 100, 86, -14}, // 13
|
|
{-64, 100, 71, -29}, // 14
|
|
{-64, 100, 87, -13}, // 15
|
|
{-64, 100, 72, -20}, // 16
|
|
{-64, 100, 88, -4}, // 17
|
|
{-64, 100, 73, -19}, // 18
|
|
{-64, 100, 89, -3}, // 19
|
|
{-64, 100, 74, -18}, // 20
|
|
{-64, 100, 90, -2}, // 21
|
|
{-64, 100, 75, -17}, // 22
|
|
{-64, 100, 91, -1}, // 23
|
|
{-64, 100, 76, -24}, // 24
|
|
{-64, 100, 92, -8}, // 25
|
|
{-64, 100, 77, -23}, // 26
|
|
{-64, 100, 93, -7}, // 27
|
|
{-64, 100, 78, -22}, // 28
|
|
{-64, 100, 94, -6}, // 29
|
|
{-64, 100, 79, -21}, // 30
|
|
{-64, 100, 95, -5} // 31
|
|
};
|
|
for (int speed = 0; speed < 32; speed++) {
|
|
byte[] packet = NmraPacket.speedStep28Packet(true, address, true, speed, false);
|
|
assertNotNull(packet);
|
|
assertArrayEquals( reverse[speed], packet, "Speed step " + speed);
|
|
}
|
|
// invalid inputs should result in null output
|
|
assertNull( NmraPacket.speedStep28Packet(true, address, true, -1, true), "Speed step -1");
|
|
JUnitAppender.assertErrorMessage("invalid speed -1");
|
|
assertNull( NmraPacket.speedStep28Packet(true, address, true, 32, true), "Speed step 32");
|
|
JUnitAppender.assertErrorMessage("invalid speed 32");
|
|
}
|
|
|
|
@Test
|
|
public void testToStringNoPacket() {
|
|
boolean thrown = false;
|
|
try {
|
|
NmraPacket.toString(new byte[]{});
|
|
} catch (IllegalArgumentException e) {
|
|
thrown = true;
|
|
}
|
|
|
|
assertTrue(thrown);
|
|
}
|
|
|
|
@Test
|
|
public void testToStringShortLocoPacket() {
|
|
// short address function set
|
|
String display = NmraPacket.toString(new byte[]{(byte) 0x3C, (byte) 0xDE, (byte) 0x55, (byte) 00});
|
|
assertEquals("LOCO_SHORT_ADDRESS type: 222 to addr 60", display);
|
|
}
|
|
|
|
@Test
|
|
public void testToStringAccessoryPacket1() {
|
|
String display = NmraPacket.toString(NmraPacket.accDecoderPkt(1, true));
|
|
assertEquals("ACCESSORY_ADDRESS type: 120 to addr 1", display);
|
|
}
|
|
|
|
@Test
|
|
public void testToStringAccessoryPacket257() {
|
|
String display = NmraPacket.toString(NmraPacket.accDecoderPkt(257, true));
|
|
assertEquals("ACCESSORY_ADDRESS type: 104 to addr 257", display);
|
|
}
|
|
|
|
@BeforeEach
|
|
public void setUp() {
|
|
JUnitUtil.setUp();
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
JUnitUtil.tearDown();
|
|
}
|
|
|
|
private static int decAddr(int accyAddr) {
|
|
return (((accyAddr - 1) >> 2) << 2) + 1;
|
|
}
|
|
|
|
}
|