Serge NOEL
233 lines
13 KiB
Java
233 lines
13 KiB
Java
package jmri.jmrix.maple;
|
|
|
|
import jmri.Manager.NameValidity;
|
|
import jmri.util.JUnitAppender;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import org.junit.Assert;
|
|
import org.junit.jupiter.api.*;
|
|
|
|
/**
|
|
* JUnit tests for the SerialAddress utility class.
|
|
*
|
|
* @author Dave Duchamp Copyright 2004
|
|
*/
|
|
public class SerialAddressTest {
|
|
|
|
@Test
|
|
public void testValidSystemNameFormat() {
|
|
Assert.assertTrue("valid format - KL2", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2", 'L', "K"));
|
|
|
|
Assert.assertTrue("invalid format - KL", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL", 'L', "K"));
|
|
JUnitAppender.assertWarnMessage("missing numerical node address in system name: KL");
|
|
|
|
Assert.assertTrue("valid format - KL2005", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2005", 'L', "K"));
|
|
Assert.assertTrue("valid format - KT2005", NameValidity.VALID == SerialAddress.validSystemNameFormat("KT2005", 'T', "K"));
|
|
Assert.assertTrue("valid format - KS205", NameValidity.VALID == SerialAddress.validSystemNameFormat("KS205", 'S', "K"));
|
|
|
|
Assert.assertTrue("invalid format - KY2005", NameValidity.VALID != SerialAddress.validSystemNameFormat("KY2005", 'L', "K"));
|
|
JUnitAppender.assertErrorMessage("invalid character in header field of system name: KY2005");
|
|
|
|
Assert.assertTrue("valid format - KL1", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL1", 'L', "K"));
|
|
Assert.assertTrue("valid format - KL1000", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL1000", 'L', "K"));
|
|
|
|
// note: address format is invalid (out of range) as checked upon user input
|
|
Assert.assertTrue("invalid format - KL0", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL0", 'L', "K"));
|
|
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL0");
|
|
|
|
Assert.assertTrue("valid format - KL2999", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2999", 'L', "K"));
|
|
|
|
Assert.assertTrue("valid format - KL7999", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL7999", 'L', "K"));
|
|
|
|
Assert.assertTrue("invalid format - KL2oo5", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL2oo5", 'L', "K"));
|
|
JUnitAppender.assertWarnMessage("invalid character in number field of system name: KL2oo5");
|
|
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL2oo5");
|
|
}
|
|
|
|
@Test
|
|
public void testGetBitFromSystemName() {
|
|
Assert.assertEquals("KL2", 2, SerialAddress.getBitFromSystemName("KL2", "K"));
|
|
Assert.assertEquals("KL2002", 2002, SerialAddress.getBitFromSystemName("KL2002", "K"));
|
|
Assert.assertEquals("KL1", 1, SerialAddress.getBitFromSystemName("KL1", "K"));
|
|
Assert.assertEquals("KL2001", 2001, SerialAddress.getBitFromSystemName("KL2001", "K"));
|
|
Assert.assertEquals("KL999", 999, SerialAddress.getBitFromSystemName("KL999", "K"));
|
|
Assert.assertEquals("KL2999", 2999, SerialAddress.getBitFromSystemName("KL2999", "K"));
|
|
|
|
Assert.assertEquals("KL29O9", 0, SerialAddress.getBitFromSystemName("KL29O9", "K"));
|
|
JUnitAppender.assertWarnMessage("invalid character in number field of system name: KL29O9");
|
|
}
|
|
|
|
@Test
|
|
public void testValidSystemNameConfig() {
|
|
InputBits.setNumInputBits(40);
|
|
OutputBits.setNumOutputBits(201);
|
|
Assert.assertTrue("valid config KL47", SerialAddress.validSystemNameConfig("KL47", 'L', memo));
|
|
Assert.assertTrue("valid config KS17", SerialAddress.validSystemNameConfig("KS17", 'S', memo));
|
|
Assert.assertTrue("valid config KL148", SerialAddress.validSystemNameConfig("KL148", 'L', memo));
|
|
Assert.assertTrue("invalid config KL1049", !SerialAddress.validSystemNameConfig("KL1049", 'L', memo));
|
|
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KL1049");
|
|
Assert.assertTrue("valid config KS24", SerialAddress.validSystemNameConfig("KS24", 'S', memo));
|
|
Assert.assertTrue("valid config KS40", SerialAddress.validSystemNameConfig("KS40", 'S', memo));
|
|
Assert.assertTrue("invalid config KS41", !SerialAddress.validSystemNameConfig("KS41", 'S', memo));
|
|
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KS41");
|
|
Assert.assertTrue("invalid config KS0", !SerialAddress.validSystemNameConfig("KS0", 'S', memo));
|
|
JUnitAppender.assertWarnMessage("node address field out of range in system name - KS0");
|
|
Assert.assertTrue("valid config KT201", SerialAddress.validSystemNameConfig("KT201", 'T', memo));
|
|
Assert.assertTrue("invalid config KT202", !SerialAddress.validSystemNameConfig("KT202", 'T', memo));
|
|
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KT202");
|
|
Assert.assertTrue("invalid config KT4129", !SerialAddress.validSystemNameConfig("KT4129", 'T', memo));
|
|
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KT4129");
|
|
}
|
|
|
|
@Test
|
|
public void testNormalizeSystemName() {
|
|
Assert.assertEquals("normalize KL007", "KL7", SerialAddress.normalizeSystemName("KL007", "K"));
|
|
Assert.assertEquals("normalize KL004007", "KL4007", SerialAddress.normalizeSystemName("KL004007", "K"));
|
|
|
|
Assert.assertEquals("normalize KL12007", "", SerialAddress.normalizeSystemName("KL12007", "K"));
|
|
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL12007");
|
|
}
|
|
|
|
@Test
|
|
public void testConstructSystemName() {
|
|
Assert.assertEquals("make KL7", "KL7", SerialAddress.makeSystemName("L", 7, "K"));
|
|
Assert.assertEquals("make KT7", "KT7", SerialAddress.makeSystemName("T", 7, "K"));
|
|
Assert.assertEquals("make KS7", "KS7", SerialAddress.makeSystemName("S", 7, "K"));
|
|
|
|
Assert.assertEquals("make illegal 1", "", SerialAddress.makeSystemName("L", 0, "K"));
|
|
JUnitAppender.assertWarnMessage("illegal address range proposed for system name - 0");
|
|
|
|
Assert.assertEquals("make illegal 2", "", SerialAddress.makeSystemName("L", 9990, "K"));
|
|
JUnitAppender.assertWarnMessage("illegal address range proposed for system name - 9990");
|
|
|
|
Assert.assertEquals("make illegal 3", "", SerialAddress.makeSystemName("R", 120, "K"));
|
|
JUnitAppender.assertErrorMessage("illegal type character proposed for system name - R");
|
|
|
|
Assert.assertEquals("make KS999", "KS999", SerialAddress.makeSystemName("S", 999, "K"));
|
|
Assert.assertEquals("make KS1000", "KS1000", SerialAddress.makeSystemName("S", 1000, "K"));
|
|
}
|
|
|
|
@Test
|
|
public void testIsOutputBitFree() {
|
|
// create a new turnout
|
|
jmri.TurnoutManager tMgr = memo.getTurnoutManager();
|
|
jmri.Turnout t1 = tMgr.newTurnout("KT034", "userT34");
|
|
// check that turnout was created correctly including normalizing system name
|
|
Assert.assertEquals("create KT34 check 1", "KT34", t1.getSystemName());
|
|
// create a new turnout
|
|
jmri.Turnout t2 = tMgr.newTurnout("KT32", "userT32");
|
|
// check that turnout was created correctly
|
|
Assert.assertEquals("create KT32 check 1", "KT32", t2.getSystemName());
|
|
// create two new lights
|
|
jmri.LightManager lMgr = memo.getLightManager();
|
|
jmri.Light lgt1 = lMgr.newLight("KL36", "userL36");
|
|
jmri.Light lgt2 = lMgr.newLight("KL037", "userL37");
|
|
// check that the lights were created as expected
|
|
Assert.assertEquals("create KL36 check", "KL36", lgt1.getSystemName());
|
|
Assert.assertEquals("create KL37 check", "KL37", lgt2.getSystemName());
|
|
// test
|
|
Assert.assertEquals("test bit 30", "", SerialAddress.isOutputBitFree(30, "K"));
|
|
Assert.assertEquals("test bit 34", "KT34", SerialAddress.isOutputBitFree(34, "K"));
|
|
Assert.assertEquals("test bit 36", "KL36", SerialAddress.isOutputBitFree(36, "K"));
|
|
Assert.assertEquals("test bit 37", "KL37", SerialAddress.isOutputBitFree(37, "K"));
|
|
Assert.assertEquals("test bit 38", "", SerialAddress.isOutputBitFree(38, "K"));
|
|
Assert.assertEquals("test bit 39", "", SerialAddress.isOutputBitFree(39, "K"));
|
|
Assert.assertEquals("test bit 1000", "", SerialAddress.isOutputBitFree(1000, "K"));
|
|
}
|
|
|
|
@Test
|
|
public void testIsInputBitFree() {
|
|
jmri.SensorManager sMgr = memo.getSensorManager();
|
|
// create 4 new sensors
|
|
jmri.Sensor s1 = sMgr.newSensor("KS16", "userS16");
|
|
jmri.Sensor s2 = sMgr.newSensor("KS014", "userS14");
|
|
jmri.Sensor s3 = sMgr.newSensor("KS17", "userS17");
|
|
jmri.Sensor s4 = sMgr.newSensor("KS12", "userS12");
|
|
// check that the sensors were created as expected
|
|
Assert.assertEquals("create KS16 check", "KS16", s1.getSystemName());
|
|
Assert.assertEquals("create KS14 check", "KS14", s2.getSystemName());
|
|
Assert.assertEquals("create KS17 check", "KS17", s3.getSystemName());
|
|
Assert.assertEquals("create KS12 check", "KS12", s4.getSystemName());
|
|
// test
|
|
Assert.assertEquals("test bit 10", "", SerialAddress.isInputBitFree(10, "K"));
|
|
Assert.assertEquals("test bit 11", "", SerialAddress.isInputBitFree(11, "K"));
|
|
Assert.assertEquals("test bit 12", "KS12", SerialAddress.isInputBitFree(12, "K"));
|
|
Assert.assertEquals("test bit 13", "", SerialAddress.isInputBitFree(13, "K"));
|
|
Assert.assertEquals("test bit 14", "KS14", SerialAddress.isInputBitFree(14, "K"));
|
|
Assert.assertEquals("test bit 15", "", SerialAddress.isInputBitFree(15, "K"));
|
|
Assert.assertEquals("test bit 16", "KS16", SerialAddress.isInputBitFree(16, "K"));
|
|
Assert.assertEquals("test bit 17", "KS17", SerialAddress.isInputBitFree(17, "K"));
|
|
Assert.assertEquals("test bit 18", "", SerialAddress.isInputBitFree(18, "K"));
|
|
}
|
|
|
|
@Test
|
|
public void testGetUserNameFromSystemName() {
|
|
jmri.SensorManager sMgr = jmri.InstanceManager.sensorManagerInstance();
|
|
// create 4 new sensors
|
|
sMgr.newSensor("KS16", "userS16");
|
|
sMgr.newSensor("KS014", "userS14");
|
|
sMgr.newSensor("KS17", "userS17");
|
|
sMgr.newSensor("KS12", "userS12");
|
|
|
|
jmri.LightManager lMgr = memo.getLightManager();
|
|
lMgr.newLight("KL36", "userL36");
|
|
lMgr.newLight("KL037", "userL37");
|
|
|
|
jmri.TurnoutManager tMgr = memo.getTurnoutManager();
|
|
tMgr.newTurnout("KT32", "userT32");
|
|
tMgr.newTurnout("KT34", "userT34");
|
|
|
|
Assert.assertEquals("test KS16", "userS16", SerialAddress.getUserNameFromSystemName("KS16", "K"));
|
|
Assert.assertEquals("test KS12", "userS12", SerialAddress.getUserNameFromSystemName("KS12", "K"));
|
|
Assert.assertEquals("test KS17", "userS17", SerialAddress.getUserNameFromSystemName("KS17", "K"));
|
|
Assert.assertEquals("test undefined KS10", "", SerialAddress.getUserNameFromSystemName("KS10", "K"));
|
|
Assert.assertEquals("test KL37", "userL37", SerialAddress.getUserNameFromSystemName("KL37", "K"));
|
|
Assert.assertEquals("test KL36", "userL36", SerialAddress.getUserNameFromSystemName("KL36", "K"));
|
|
Assert.assertEquals("test undefined KL30", "", SerialAddress.getUserNameFromSystemName("KL30", "K"));
|
|
Assert.assertEquals("test KT32", "userT32", SerialAddress.getUserNameFromSystemName("KT32", "K"));
|
|
Assert.assertEquals("test KT34", "userT34", SerialAddress.getUserNameFromSystemName("KT34", "K"));
|
|
Assert.assertEquals("test undefined KT39", "", SerialAddress.getUserNameFromSystemName("KT39", "K"));
|
|
}
|
|
|
|
// from here down is testing infrastructure
|
|
|
|
@BeforeEach
|
|
public void setUp() {
|
|
JUnitUtil.setUp();
|
|
// create and register the manager objects
|
|
SerialTrafficControlScaffold tc = new SerialTrafficControlScaffold();
|
|
memo = new MapleSystemConnectionMemo("K", "Maple");
|
|
memo.setTrafficController(tc);
|
|
new InputBits(tc);
|
|
new OutputBits(tc);
|
|
new SerialNode(4, 0,tc);
|
|
new SerialNode(10, 0,tc);
|
|
new SerialNode(99, 0,tc);
|
|
new SerialNode(18, 0,tc);
|
|
|
|
SerialTurnoutManager l = new SerialTurnoutManager(memo);
|
|
jmri.InstanceManager.setTurnoutManager(l);
|
|
|
|
memo.setTurnoutManager(l);
|
|
|
|
SerialLightManager lgt = new SerialLightManager(memo);
|
|
jmri.InstanceManager.setLightManager(lgt);
|
|
memo.setLightManager(lgt);
|
|
|
|
SerialSensorManager s = new SerialSensorManager(memo);
|
|
jmri.InstanceManager.setSensorManager(s);
|
|
memo.setSensorManager(s);
|
|
}
|
|
|
|
private MapleSystemConnectionMemo memo = null;
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
memo = null;
|
|
JUnitUtil.clearShutDownManager(); // put in place because AbstractMRTrafficController implementing subclass was not terminated properly
|
|
JUnitUtil.tearDown();
|
|
|
|
}
|
|
|
|
}
|