Serge NOEL
353 lines
16 KiB
Java
353 lines
16 KiB
Java
package jmri.jmrit.logix;
|
|
|
|
import jmri.*;
|
|
import jmri.util.JUnitAppender;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
/**
|
|
*
|
|
* @author Bob Jacobsen Copyright 2010, 2014
|
|
*/
|
|
public class OBlockTest {
|
|
|
|
private OBlockManager blkMgr;
|
|
|
|
/* OBlock.DARK replaced with Block.UNDETECTED - 12/10/2016 pwc
|
|
@SuppressWarnings("all") // otherwise, you get "Comparing identical" warning (until something breaks!)
|
|
public void testEqualCoding() {
|
|
// the following match is required by the Javadoc
|
|
Assert.assertTrue("Block.UNKNOWN == OBlock.DARK", Block.UNKNOWN == OBlock.DARK);
|
|
}*/
|
|
|
|
@Test
|
|
public void testCTor(){
|
|
assertNotNull(new OBlock("OB01"),"OBlock Creation");
|
|
}
|
|
|
|
@Test
|
|
public void testCTor2Param(){
|
|
assertNotNull(new OBlock("OB01","test OBlock"),"OBlock Creation");
|
|
}
|
|
|
|
@Test
|
|
public void testSeparateCoding() {
|
|
assertTrue( Block.OCCUPIED != OBlock.ALLOCATED, "Block.OCCUPIED != OBlock.ALLOCATED");
|
|
assertTrue( Block.OCCUPIED != OBlock.RUNNING, "Block.OCCUPIED != OBlock.RUNNING");
|
|
assertTrue( Block.OCCUPIED != OBlock.OUT_OF_SERVICE, "Block.OCCUPIED != OBlock.OUT_OF_SERVICE");
|
|
assertTrue( Block.OCCUPIED != OBlock.TRACK_ERROR, "Block.OCCUPIED != OBlock.TRACK_ERROR");
|
|
assertTrue( Block.OCCUPIED != OBlock.UNOCCUPIED, "Block.OCCUPIED != OBlock.UNOCCUPIED");
|
|
|
|
assertTrue( Block.UNOCCUPIED != OBlock.ALLOCATED, "Block.UNOCCUPIED != OBlock.ALLOCATED");
|
|
assertTrue( Block.UNOCCUPIED != OBlock.RUNNING, "Block.UNOCCUPIED != OBlock.RUNNING");
|
|
assertTrue( Block.UNOCCUPIED != OBlock.OUT_OF_SERVICE, "Block.UNOCCUPIED != OBlock.OUT_OF_SERVICE");
|
|
assertTrue( Block.UNOCCUPIED != OBlock.TRACK_ERROR, "Block.UNOCCUPIED != OBlock.TRACK_ERROR");
|
|
|
|
assertTrue( Block.UNDETECTED != OBlock.ALLOCATED, "Block.UNDETECTED != OBlock.ALLOCATED");
|
|
assertTrue( Block.UNDETECTED != OBlock.RUNNING, "Block.UNDETECTED != OBlock.RUNNING");
|
|
assertTrue( Block.UNDETECTED != OBlock.OUT_OF_SERVICE, "Block.UNDETECTED != OBlock.OUT_OF_SERVICE");
|
|
assertTrue( Block.UNDETECTED != OBlock.TRACK_ERROR, "Block.UNDETECTED != OBlock.TRACK_ERROR");
|
|
assertTrue( Block.UNDETECTED != OBlock.UNOCCUPIED, "Block.UNDETECTED != OBlock.UNOCCUPIED");
|
|
|
|
assertTrue( Block.UNKNOWN != OBlock.ALLOCATED, "Block.UNKNOWN != OBlock.ALLOCATED");
|
|
assertTrue( Block.UNKNOWN != OBlock.RUNNING, "Block.UNKNOWN != OBlock.RUNNING");
|
|
assertTrue( Block.UNKNOWN != OBlock.OUT_OF_SERVICE, "Block.UNKNOWN != OBlock.OUT_OF_SERVICE");
|
|
assertTrue( Block.UNKNOWN != OBlock.TRACK_ERROR, "Block.UNKNOWN != OBlock.TRACK_ERROR");
|
|
assertTrue( Block.UNKNOWN != OBlock.UNOCCUPIED, "Block.UNKNOWN != OBlock.UNOCCUPIED");
|
|
}
|
|
|
|
@Test
|
|
public void testSetSensor() throws JmriException {
|
|
OBlock b = blkMgr.createNewOBlock("OB100", "a");
|
|
assertNotNull(b);
|
|
assertFalse( b.setSensor("foo"), "setSensor");
|
|
JUnitAppender.assertErrorMessage("No sensor named 'foo' exists.");
|
|
assertNull( b.getSensor(), "getSensor");
|
|
|
|
SensorManager sensorMgr = InstanceManager.getDefault(SensorManager.class);
|
|
Sensor s1 = sensorMgr.newSensor("IS1", "sensor1");
|
|
assertTrue( b.setSensor("sensor1"), "setSensor");
|
|
assertEquals( s1, b.getSensor(), "getSensor");
|
|
assertEquals( OBlock.UNKNOWN, b.getState(), "state unknown");
|
|
|
|
assertTrue( b.setSensor("IS1"), "dup setSensor");
|
|
assertEquals( s1, b.getSensor(), "dup getSensor s1");
|
|
assertEquals( OBlock.UNKNOWN, b.getState(), "dup state unknown");
|
|
|
|
assertTrue( b.setSensor(" "), "setSensor none");
|
|
assertNull( b.getSensor(), "getSensor none");
|
|
assertEquals( OBlock.UNDETECTED, b.getState(), "none state dark");
|
|
|
|
assertTrue( b.isFree(), "Not Free");
|
|
b.setState(b.getState() | OBlock.ALLOCATED|OBlock.RUNNING);
|
|
assertFalse( b.isFree(), "Is Free");
|
|
s1.setState(Sensor.ACTIVE);
|
|
assertTrue( b.setSensor("sensor1"), "setSensor sensor1");
|
|
assertEquals( OBlock.OCCUPIED|OBlock.ALLOCATED|OBlock.RUNNING, b.getState(), "state allocated&running");
|
|
}
|
|
|
|
@Test
|
|
public void testSetErrorSensor() throws JmriException {
|
|
OBlock b = blkMgr.createNewOBlock("OB101", "b");
|
|
assertNotNull(b);
|
|
assertFalse( b.setErrorSensor("foo"), "setErrorSensor foo");
|
|
JUnitAppender.assertErrorMessage("No sensor named 'foo' exists.");
|
|
assertNull( b.getErrorSensor(), "getErrorSensor foo");
|
|
|
|
SensorManager sensorMgr = InstanceManager.getDefault(SensorManager.class);
|
|
Sensor se = sensorMgr.newSensor("ISE1", "error1");
|
|
se.setState(Sensor.ACTIVE);
|
|
assertTrue( b.setErrorSensor("error1"), "setErrorSensor only");
|
|
assertEquals( se, b.getErrorSensor(), "getErrorSensor only");
|
|
assertEquals( OBlock.TRACK_ERROR | OBlock.UNDETECTED, b.getState(), "state error only");
|
|
|
|
Sensor s1 = sensorMgr.newSensor("IS1", "sensor1");
|
|
s1.setState(Sensor.ACTIVE);
|
|
assertTrue( b.setSensor("IS1"), "setSensor");
|
|
assertEquals( se, b.getErrorSensor(), "getErrorSensor se");
|
|
assertEquals( OBlock.TRACK_ERROR | OBlock.OCCUPIED, b.getState(), "state error");
|
|
|
|
assertTrue( b.setErrorSensor(" "), "setErrorSensor");
|
|
assertNull( b.getErrorSensor(), "getErrorSensor none");
|
|
assertEquals( OBlock.OCCUPIED, b.getState(), "state dark");
|
|
}
|
|
|
|
@Test
|
|
public void testAllocate() {
|
|
Warrant w1 = new Warrant("IW1", null);
|
|
w1.setTrainName("T1");
|
|
Warrant w2 = new Warrant("IW2", null);
|
|
OBlock b = blkMgr.createNewOBlock("OB102", "c");
|
|
assertNotNull(b);
|
|
assertEquals( OBlock.UNDETECTED, b.getState(), "state is dark");
|
|
assertNull( b.allocate(w1), "Allocate w1");
|
|
assertEquals(
|
|
Bundle.getMessage("AllocatedToWarrant", w1.getDisplayName(), b.getDisplayName(), w1.getTrainName()),
|
|
b.allocate(w2), "Allocate w2");
|
|
|
|
assertEquals(
|
|
Bundle.getMessage("PathNotFound", "PathName", b.getDisplayName()),
|
|
b.setPath("PathName", w1), "path not found");
|
|
OPath path1 = new OPath(b, "path1");
|
|
b.addPath(path1);
|
|
assertNull( b.setPath("path1", w1), "path set");
|
|
assertFalse( b.isAllocatedTo(w2), "Allocated to w2");
|
|
assertTrue( b.isAllocatedTo(w1), "Allocated to w1");
|
|
|
|
assertTrue( b.deAllocate(w1), "DeAllocate null");
|
|
b.setOutOfService(true);
|
|
assertNull( b.allocate(w2), "Allocate w2");
|
|
b.setOutOfService(false);
|
|
assertTrue( b.deAllocate(w2), "deAllocate w2");
|
|
|
|
assertEquals(
|
|
Bundle.getMessage("PathNotSet", "path1", b.getDisplayName(), Bundle.getMessage("Warrant")),
|
|
b.setPath("path1", w1), "PathNotSet");
|
|
assertNull( b.allocate(w1), "Allocate w1");
|
|
assertEquals(
|
|
Bundle.getMessage("PathNotSet", "path1", b.getDisplayName(), w1.getDisplayName()),
|
|
b.setPath("path1", w2),"path not set");
|
|
}
|
|
|
|
@Test
|
|
public void testSensorChanges() throws JmriException {
|
|
OBlock b = blkMgr.createNewOBlock("OB103", null);
|
|
assertNotNull(b);
|
|
Warrant w0 = new Warrant("IW0", "war0");
|
|
b.setOutOfService(true);
|
|
assertEquals( OBlock.UNDETECTED|OBlock.OUT_OF_SERVICE, b.getState(),"state OutOfService & dark");
|
|
|
|
SensorManager sensorMgr = InstanceManager.getDefault(SensorManager.class);
|
|
Sensor s0 = sensorMgr.newSensor("IS0", "sensor0");
|
|
assertTrue( b.setSensor("sensor0"), "setSensor");
|
|
assertEquals( OBlock.UNKNOWN|OBlock.OUT_OF_SERVICE, b.getState(), "state unknown & dark");
|
|
b.setOutOfService(false);
|
|
assertNull( b.allocate(w0), "Allocate w0");
|
|
assertEquals( OBlock.ALLOCATED|OBlock.UNKNOWN, b.getState(), "state allocated & unknown");
|
|
s0.setState(Sensor.ACTIVE);
|
|
assertEquals( OBlock.ALLOCATED|OBlock.OCCUPIED, b.getState(), "state allocated & unknown");
|
|
assertTrue( b.deAllocate(w0), "DeAllocate w0");
|
|
b.setOutOfService(true);
|
|
s0.setState(Sensor.INACTIVE);
|
|
assertEquals( OBlock.OUT_OF_SERVICE|OBlock.UNOCCUPIED, b.getState(), "state allocated & unknown");
|
|
b.setError(false);
|
|
s0.setState(Sensor.INCONSISTENT);
|
|
assertEquals( OBlock.OUT_OF_SERVICE|OBlock.INCONSISTENT, b.getState(), "state OutOfService & inconsistent");
|
|
assertTrue( b.setSensor(null), "setSensor none");
|
|
assertEquals( OBlock.OUT_OF_SERVICE|OBlock.UNDETECTED, b.getState(), "state OutOfService & dark");
|
|
}
|
|
|
|
@Test
|
|
public void testAddPortal() {
|
|
OBlock b = blkMgr.createNewOBlock("OB0", "");
|
|
assertNotNull(b);
|
|
PortalManager portalMgr = InstanceManager.getDefault(PortalManager.class);
|
|
Portal p = portalMgr.providePortal("Doop");
|
|
b.addPortal(p);
|
|
assertEquals( 0, b.getPortals().size(), "No portals");
|
|
|
|
p.setFromBlock(b, true);
|
|
b.addPortal(p);
|
|
assertEquals( 1, b.getPortals().size(), "One portal");
|
|
p.setToBlock(b, true);
|
|
b.addPortal(p);
|
|
assertEquals( 1, b.getPortals().size(), "One portal only");
|
|
p = portalMgr.providePortal("barp");
|
|
b.addPortal(p);
|
|
p.setToBlock(b, false);
|
|
assertEquals( 2, b.getPortals().size(), "Two portals");
|
|
|
|
assertEquals( p, b.getPortalByName("barp"), "Same Portal");
|
|
p = b.getPortalByName("Doop");
|
|
assertNotNull(p, "Get Portal");
|
|
b.removePortal(p);
|
|
assertEquals( 1, b.getPortals().size(), "One portal");
|
|
|
|
JUnitAppender.assertWarnMessage("Portal \"Doop\" between OBlocks \"null\" and \"null\" not in block OB0");
|
|
JUnitAppender.assertWarnMessage("Portal \"barp\" between OBlocks \"null\"and \"null\" not in block OB0");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testAddPath() {
|
|
OBlock b = blkMgr.createNewOBlock("OB1", "");
|
|
assertNotNull(b);
|
|
OPath path1 = new OPath(b, "path1");
|
|
// also test the "add" method checks
|
|
PortalManager portalMgr = InstanceManager.getDefault(PortalManager.class);
|
|
path1.setToPortal(portalMgr.providePortal("foo"));
|
|
assertFalse( b.addPath(path1), "add path1 to block path1 not in foo");
|
|
portalMgr.providePortal("foo").addPath(path1);
|
|
assertFalse( b.addPath(path1), "add path1 to block b not in foo");
|
|
portalMgr.providePortal("foo").setFromBlock(b, false);
|
|
assertTrue( b.addPath(path1), "add path1 to block");
|
|
assertEquals( 1, b.getPaths().size(), "One path");
|
|
OBlock bb = blkMgr.createNewOBlock("OB2", "");
|
|
OPath path2 = new OPath(bb, "path2");
|
|
assertFalse( b.addPath(path2), "path2 not in block");
|
|
assertEquals( 1, b.getPaths().size(), "path2 not in block");
|
|
JUnitAppender.assertWarnMessage("Path \"path2\" already in block OB2, cannot be added to block OB1");
|
|
|
|
assertFalse( b.addPath(path1), "path1 already in block");
|
|
assertEquals( 1, b.getPaths().size(), "path1 already in block");
|
|
OPath path11 = new OPath(b, "path1");
|
|
assertFalse( b.addPath(path11), "path with name \"path1\" already in block");
|
|
assertEquals(1, b.getPaths().size(), "path with name \"path1\" already in block");
|
|
|
|
path2 = new OPath("path2", b, portalMgr.providePortal("bar"), null, null);
|
|
portalMgr.providePortal("bar").addPath(path2);
|
|
portalMgr.providePortal("bar").setToBlock(b, false);
|
|
assertTrue(b.addPath(path2), "path2 in block");
|
|
assertEquals( path1, b.getPathByName("path1"), "get \"path1\"");
|
|
|
|
b.removeOPath(path1);
|
|
b.removeOPath(path2);
|
|
assertEquals( 0, b.getPaths().size(), "no paths");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testAddUserName() {
|
|
OBlock b = blkMgr.provideOBlock("OB99");
|
|
assertNotNull( b, "Block OB99 is null");
|
|
b.setUserName("99user");
|
|
b = blkMgr.getBySystemName("OB99");
|
|
assertNotNull(b);
|
|
assertEquals( "99user", b.getUserName(), "UserName not kept");
|
|
}
|
|
|
|
@Test
|
|
public void testGetLocalStatusName() {
|
|
assertEquals( Bundle.getMessage("unoccupied"), OBlock.getLocalStatusName("unoccupied"));
|
|
assertEquals( Bundle.getMessage("occupied"), OBlock.getLocalStatusName("occupied"));
|
|
assertEquals( Bundle.getMessage("allocated"), OBlock.getLocalStatusName("allocated"));
|
|
assertEquals( Bundle.getMessage("running"), OBlock.getLocalStatusName("running"));
|
|
assertEquals( Bundle.getMessage("outOfService"), OBlock.getLocalStatusName("outOfService"));
|
|
assertEquals( Bundle.getMessage("dark"), OBlock.getLocalStatusName("dark"));
|
|
assertEquals( Bundle.getMessage("powerError"), OBlock.getLocalStatusName("powerError"));
|
|
}
|
|
|
|
@Test
|
|
public void testGetSystemStatusName() {
|
|
assertEquals("unoccupied", OBlock.getSystemStatusName(Bundle.getMessage("unoccupied")));
|
|
assertEquals("occupied", OBlock.getSystemStatusName(Bundle.getMessage("occupied")));
|
|
assertEquals("allocated", OBlock.getSystemStatusName(Bundle.getMessage("allocated")));
|
|
assertEquals("running", OBlock.getSystemStatusName(Bundle.getMessage("running")));
|
|
assertEquals("outOfService", OBlock.getSystemStatusName(Bundle.getMessage("outOfService")));
|
|
assertEquals("dark", OBlock.getSystemStatusName(Bundle.getMessage("dark")));
|
|
assertEquals("powerError", OBlock.getSystemStatusName(Bundle.getMessage("powerError")));
|
|
}
|
|
|
|
@Test
|
|
public void testStatusIs() {
|
|
|
|
OBlock oblock = new OBlock("OB99");
|
|
|
|
oblock.setState(OBlock.UNOCCUPIED);
|
|
assertTrue(oblock.statusIs("unoccupied"));
|
|
oblock.setState(OBlock.OCCUPIED);
|
|
assertTrue(oblock.statusIs("occupied"));
|
|
oblock.setState(OBlock.ALLOCATED);
|
|
assertTrue(oblock.statusIs("allocated"));
|
|
oblock.setState(OBlock.RUNNING);
|
|
assertTrue(oblock.statusIs("running"));
|
|
oblock.setState(OBlock.OUT_OF_SERVICE);
|
|
assertTrue(oblock.statusIs("outOfService"));
|
|
oblock.setState(OBlock.UNDETECTED);
|
|
assertTrue(oblock.statusIs("dark"));
|
|
oblock.setState(OBlock.TRACK_ERROR);
|
|
assertTrue(oblock.statusIs("powerError"));
|
|
}
|
|
|
|
@Test
|
|
public void testOBlockStatusEnum() {
|
|
assertEquals(OBlock.UNOCCUPIED, OBlock.OBlockStatus.Unoccupied.getStatus());
|
|
assertEquals("unoccupied", OBlock.OBlockStatus.Unoccupied.getName());
|
|
assertEquals(Bundle.getMessage("unoccupied"), OBlock.OBlockStatus.Unoccupied.getDescr());
|
|
|
|
assertEquals(OBlock.OCCUPIED, OBlock.OBlockStatus.Occupied.getStatus());
|
|
assertEquals("occupied", OBlock.OBlockStatus.Occupied.getName());
|
|
assertEquals(Bundle.getMessage("occupied"), OBlock.OBlockStatus.Occupied.getDescr());
|
|
|
|
assertEquals(OBlock.ALLOCATED, OBlock.OBlockStatus.Allocated.getStatus());
|
|
assertEquals("allocated", OBlock.OBlockStatus.Allocated.getName());
|
|
assertEquals(Bundle.getMessage("allocated"), OBlock.OBlockStatus.Allocated.getDescr());
|
|
|
|
assertEquals(OBlock.RUNNING, OBlock.OBlockStatus.Running.getStatus());
|
|
assertEquals("running", OBlock.OBlockStatus.Running.getName());
|
|
assertEquals(Bundle.getMessage("running"), OBlock.OBlockStatus.Running.getDescr());
|
|
|
|
assertEquals(OBlock.OUT_OF_SERVICE, OBlock.OBlockStatus.OutOfService.getStatus());
|
|
assertEquals("outOfService", OBlock.OBlockStatus.OutOfService.getName());
|
|
assertEquals(Bundle.getMessage("outOfService"), OBlock.OBlockStatus.OutOfService.getDescr());
|
|
|
|
assertEquals(OBlock.UNDETECTED, OBlock.OBlockStatus.Dark.getStatus());
|
|
assertEquals("dark", OBlock.OBlockStatus.Dark.getName());
|
|
assertEquals(Bundle.getMessage("dark"), OBlock.OBlockStatus.Dark.getDescr());
|
|
|
|
assertEquals(OBlock.TRACK_ERROR, OBlock.OBlockStatus.TrackError.getStatus());
|
|
assertEquals("powerError", OBlock.OBlockStatus.TrackError.getName());
|
|
assertEquals(Bundle.getMessage("powerError"), OBlock.OBlockStatus.TrackError.getDescr());
|
|
}
|
|
|
|
// from here down is testing infrastructure
|
|
@BeforeEach
|
|
public void setUp() {
|
|
JUnitUtil.setUp();
|
|
blkMgr = new OBlockManager();
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
if (blkMgr != null ) {
|
|
blkMgr.dispose();
|
|
blkMgr = null;
|
|
}
|
|
JUnitUtil.tearDown();
|
|
}
|
|
|
|
}
|