Serge NOEL
991 lines
42 KiB
Java
991 lines
42 KiB
Java
package jmri.jmrit.display.layoutEditor;
|
|
|
|
import java.awt.geom.*;
|
|
|
|
import jmri.*;
|
|
import jmri.util.*;
|
|
|
|
import org.junit.Assert;
|
|
import org.junit.jupiter.api.*;
|
|
import org.junit.jupiter.api.condition.DisabledIfSystemProperty;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
/**
|
|
* Test simple functioning of LayoutTurnout.
|
|
*
|
|
* @author Paul Bender Copyright (C) 2016
|
|
* @author Bob Jacobsen Copyright (C) 2020
|
|
*/
|
|
@DisabledIfSystemProperty(named ="java.awt.headless", matches ="true")
|
|
public class LayoutTurnoutTest extends LayoutTrackTest {
|
|
|
|
@Test
|
|
public void testEnums() {
|
|
// Check that enum ordinal values used for I/O don't
|
|
// change. Want to remove this once I/O is done
|
|
// via enum names instead of numbers.
|
|
|
|
Assert.assertEquals(0, LayoutTurnout.TurnoutType.NONE.ordinal());
|
|
Assert.assertEquals(1, LayoutTurnout.TurnoutType.RH_TURNOUT.ordinal());
|
|
Assert.assertEquals(2, LayoutTurnout.TurnoutType.LH_TURNOUT.ordinal());
|
|
Assert.assertEquals(3, LayoutTurnout.TurnoutType.WYE_TURNOUT.ordinal());
|
|
Assert.assertEquals(4, LayoutTurnout.TurnoutType.DOUBLE_XOVER.ordinal());
|
|
Assert.assertEquals(5, LayoutTurnout.TurnoutType.RH_XOVER.ordinal());
|
|
Assert.assertEquals(6, LayoutTurnout.TurnoutType.LH_XOVER.ordinal());
|
|
Assert.assertEquals(7, LayoutTurnout.TurnoutType.SINGLE_SLIP.ordinal());
|
|
Assert.assertEquals(8, LayoutTurnout.TurnoutType.DOUBLE_SLIP.ordinal());
|
|
|
|
Assert.assertEquals(0, LayoutTurnout.LinkType.NO_LINK.ordinal());
|
|
Assert.assertEquals(1, LayoutTurnout.LinkType.FIRST_3_WAY.ordinal());
|
|
Assert.assertEquals(2, LayoutTurnout.LinkType.SECOND_3_WAY.ordinal());
|
|
Assert.assertEquals(3, LayoutTurnout.LinkType.THROAT_TO_THROAT.ordinal());
|
|
}
|
|
|
|
@Test
|
|
public void testNew() {
|
|
|
|
Assert.assertNotNull("LayoutTurnout right hand not null", ltRH);
|
|
Assert.assertNotNull("LayoutTurnout left hand not null", ltLH);
|
|
Assert.assertNotNull("LayoutTurnout wye not null", ltWY);
|
|
Assert.assertNotNull("LayoutTurnout double crossover not null", ltDX);
|
|
Assert.assertNotNull("LayoutTurnout right hand crossover not null", ltRX);
|
|
Assert.assertNotNull("LayoutTurnout left hand crossover not null", ltLX);
|
|
}
|
|
|
|
@Test
|
|
public void testToString() {
|
|
String s = ltRH.toString();
|
|
Assert.assertNotNull("LayoutTurnout right hand toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Right Hand", s);
|
|
|
|
s = ltLH.toString();
|
|
Assert.assertNotNull("LayoutTurnout left hand toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Left Hand", s);
|
|
|
|
s = ltWY.toString();
|
|
Assert.assertNotNull("LayoutTurnout wye toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Wye", s);
|
|
|
|
s = ltDX.toString();
|
|
Assert.assertNotNull("LayoutTurnout double crossover toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Double XOver", s);
|
|
|
|
s = ltRX.toString();
|
|
Assert.assertNotNull("LayoutTurnout right hand crossover toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Right Hand XOver", s);
|
|
|
|
s = ltLX.toString();
|
|
Assert.assertNotNull("LayoutTurnout left hand crossover toString() not null", s);
|
|
Assert.assertEquals("LayoutTurnout Left Hand XOver", s);
|
|
}
|
|
|
|
@Test
|
|
public void testGetVersion() {
|
|
assertEquals(1, ltRH.getVersion());
|
|
assertEquals(1, ltLH.getVersion());
|
|
assertEquals(1, ltWY.getVersion());
|
|
assertEquals(1, ltDX.getVersion());
|
|
assertEquals(1, ltRX.getVersion());
|
|
assertEquals(1, ltLX.getVersion());
|
|
}
|
|
|
|
@Test
|
|
public void testSetVersion() {
|
|
ltRH.setVersion(2);
|
|
assertEquals(2, ltRH.getVersion());
|
|
ltLH.setVersion(2);
|
|
assertEquals(2, ltLH.getVersion());
|
|
ltWY.setVersion(2);
|
|
assertEquals(2, ltWY.getVersion());
|
|
ltDX.setVersion(2);
|
|
assertEquals(2, ltDX.getVersion());
|
|
ltRX.setVersion(2);
|
|
assertEquals(2, ltRX.getVersion());
|
|
ltLX.setVersion(2);
|
|
assertEquals(2, ltLX.getVersion());
|
|
}
|
|
|
|
@Test
|
|
public void testUseBlockSpeed() {
|
|
Assert.assertFalse(ltRH.useBlockSpeed());
|
|
Assert.assertFalse(ltLH.useBlockSpeed());
|
|
Assert.assertFalse(ltWY.useBlockSpeed());
|
|
Assert.assertFalse(ltDX.useBlockSpeed());
|
|
Assert.assertFalse(ltRX.useBlockSpeed());
|
|
Assert.assertFalse(ltLX.useBlockSpeed());
|
|
}
|
|
|
|
@Test
|
|
public void testGetTurnoutName() {
|
|
assertEquals("", ltRH.getTurnoutName());
|
|
assertEquals("", ltLH.getTurnoutName());
|
|
assertEquals("", ltWY.getTurnoutName());
|
|
assertEquals("", ltDX.getTurnoutName());
|
|
assertEquals("", ltRX.getTurnoutName());
|
|
assertEquals("", ltLX.getTurnoutName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetSecondTurnoutName() {
|
|
assertEquals("", ltRH.getSecondTurnoutName());
|
|
assertEquals("", ltLH.getSecondTurnoutName());
|
|
assertEquals("", ltWY.getSecondTurnoutName());
|
|
assertEquals("", ltDX.getSecondTurnoutName());
|
|
assertEquals("", ltRX.getSecondTurnoutName());
|
|
assertEquals("", ltLX.getSecondTurnoutName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetBlockName() {
|
|
assertEquals("", ltRH.getBlockName());
|
|
assertEquals("", ltLH.getBlockName());
|
|
assertEquals("", ltWY.getBlockName());
|
|
assertEquals("", ltDX.getBlockName());
|
|
assertEquals("", ltRX.getBlockName());
|
|
assertEquals("", ltLX.getBlockName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetBlockBName() {
|
|
assertEquals("", ltRH.getBlockBName());
|
|
assertEquals("", ltLH.getBlockBName());
|
|
assertEquals("", ltWY.getBlockBName());
|
|
assertEquals("", ltDX.getBlockBName());
|
|
assertEquals("", ltRX.getBlockBName());
|
|
assertEquals("", ltLX.getBlockBName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetBlockCName() {
|
|
assertEquals("", ltRH.getBlockCName());
|
|
assertEquals("", ltLH.getBlockCName());
|
|
assertEquals("", ltWY.getBlockCName());
|
|
assertEquals("", ltDX.getBlockCName());
|
|
assertEquals("", ltRX.getBlockCName());
|
|
assertEquals("", ltLX.getBlockCName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetBlockDName() {
|
|
assertEquals("", ltRH.getBlockDName());
|
|
assertEquals("", ltLH.getBlockDName());
|
|
assertEquals("", ltWY.getBlockDName());
|
|
assertEquals("", ltDX.getBlockDName());
|
|
assertEquals("", ltRX.getBlockDName());
|
|
assertEquals("", ltLX.getBlockDName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetSignalHead() {
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.NONE));
|
|
JUnitAppender.assertWarnMessage("Right Hand.getSignalHead(NONE); Unhandled point type");
|
|
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTA1));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTA2));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTA3));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTB1));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTB2));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTC1));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTC2));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTD1));
|
|
assertNull(ltRH.getSignalHead(LayoutTurnout.Geometry.POINTD2));
|
|
}
|
|
|
|
@Test
|
|
public void testGetLinkedTurnoutName() {
|
|
assertEquals("", ltRH.getLinkedTurnoutName());
|
|
assertEquals("", ltLH.getLinkedTurnoutName());
|
|
assertEquals("", ltWY.getLinkedTurnoutName());
|
|
assertEquals("", ltDX.getLinkedTurnoutName());
|
|
assertEquals("", ltRX.getLinkedTurnoutName());
|
|
assertEquals("", ltLX.getLinkedTurnoutName());
|
|
}
|
|
|
|
@Test
|
|
public void testSetLinkedTurnoutName() {
|
|
ltRH.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltRH.getLinkedTurnoutName());
|
|
|
|
ltLH.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltLH.getLinkedTurnoutName());
|
|
|
|
ltWY.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltWY.getLinkedTurnoutName());
|
|
|
|
ltDX.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltDX.getLinkedTurnoutName());
|
|
|
|
ltRX.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltRX.getLinkedTurnoutName());
|
|
|
|
ltLX.setLinkedTurnoutName("Foo");
|
|
assertEquals("Foo", ltLX.getLinkedTurnoutName());
|
|
}
|
|
|
|
@Test
|
|
public void testGetLinkType() {
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltRH.getLinkType());
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltLH.getLinkType());
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltWY.getLinkType());
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltDX.getLinkType());
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltRX.getLinkType());
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltLX.getLinkType());
|
|
}
|
|
|
|
@Test
|
|
public void testSetLinkType() {
|
|
ltRH.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltRH.getLinkType());
|
|
ltLH.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltLH.getLinkType());
|
|
ltWY.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltWY.getLinkType());
|
|
ltDX.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltDX.getLinkType());
|
|
ltRX.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltRX.getLinkType());
|
|
ltLX.setLinkType(LayoutTurnout.LinkType.THROAT_TO_THROAT);
|
|
assertEquals(LayoutTurnout.LinkType.THROAT_TO_THROAT, ltLX.getLinkType());
|
|
|
|
ltRH.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltRH.getLinkType());
|
|
ltLH.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltLH.getLinkType());
|
|
ltWY.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltWY.getLinkType());
|
|
ltDX.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltDX.getLinkType());
|
|
ltRX.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltRX.getLinkType());
|
|
ltLX.setLinkType(LayoutTurnout.LinkType.NO_LINK);
|
|
assertEquals(LayoutTurnout.LinkType.NO_LINK, ltLX.getLinkType());
|
|
}
|
|
|
|
@Test
|
|
public void testGetTurnoutType() {
|
|
assertEquals(LayoutTurnout.TurnoutType.RH_TURNOUT, ltRH.getTurnoutType());
|
|
assertEquals(LayoutTurnout.TurnoutType.LH_TURNOUT, ltLH.getTurnoutType() );
|
|
assertEquals(LayoutTurnout.TurnoutType.WYE_TURNOUT, ltWY.getTurnoutType());
|
|
assertEquals(LayoutTurnout.TurnoutType.DOUBLE_XOVER, ltDX.getTurnoutType());
|
|
assertEquals(LayoutTurnout.TurnoutType.RH_XOVER, ltRX.getTurnoutType());
|
|
assertEquals(LayoutTurnout.TurnoutType.LH_XOVER, ltLX.getTurnoutType());
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectA() {
|
|
Assert.assertNull(ltRH.getConnectA());
|
|
Assert.assertNull(ltLH.getConnectA());
|
|
Assert.assertNull(ltWY.getConnectA());
|
|
Assert.assertNull(ltDX.getConnectA());
|
|
Assert.assertNull(ltRX.getConnectA());
|
|
Assert.assertNull(ltLX.getConnectA());
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectB() {
|
|
Assert.assertNull(ltRH.getConnectB());
|
|
Assert.assertNull(ltLH.getConnectB());
|
|
Assert.assertNull(ltWY.getConnectB());
|
|
Assert.assertNull(ltDX.getConnectB());
|
|
Assert.assertNull(ltRX.getConnectB());
|
|
Assert.assertNull(ltLX.getConnectB());
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectC() {
|
|
Assert.assertNull(ltRH.getConnectC());
|
|
Assert.assertNull(ltLH.getConnectC());
|
|
Assert.assertNull(ltWY.getConnectC());
|
|
Assert.assertNull(ltDX.getConnectC());
|
|
Assert.assertNull(ltRX.getConnectC());
|
|
Assert.assertNull(ltLX.getConnectC());
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectD() {
|
|
Assert.assertNull(ltRH.getConnectD());
|
|
Assert.assertNull(ltLH.getConnectD());
|
|
Assert.assertNull(ltWY.getConnectD());
|
|
Assert.assertNull(ltDX.getConnectD());
|
|
Assert.assertNull(ltRX.getConnectD());
|
|
Assert.assertNull(ltLX.getConnectD());
|
|
}
|
|
|
|
@Test
|
|
public void testGetTurnout() {
|
|
Assert.assertNull(ltRH.getTurnout());
|
|
Assert.assertNull(ltLH.getTurnout());
|
|
Assert.assertNull(ltWY.getTurnout());
|
|
Assert.assertNull(ltDX.getTurnout());
|
|
Assert.assertNull(ltRX.getTurnout());
|
|
Assert.assertNull(ltLX.getTurnout());
|
|
}
|
|
|
|
@Test
|
|
public void testGetContinuingSense() {
|
|
assertEquals(Turnout.CLOSED, ltRH.getContinuingSense());
|
|
assertEquals(Turnout.CLOSED, ltLH.getContinuingSense());
|
|
assertEquals(Turnout.CLOSED, ltWY.getContinuingSense());
|
|
assertEquals(Turnout.CLOSED, ltDX.getContinuingSense());
|
|
assertEquals(Turnout.CLOSED, ltRX.getContinuingSense());
|
|
assertEquals(Turnout.CLOSED, ltLX.getContinuingSense());
|
|
}
|
|
|
|
@Test
|
|
public void testIsDisabledDefault() {
|
|
Assert.assertFalse("ltRH.isDisabled() is False", ltRH.isDisabled());
|
|
Assert.assertFalse("ltLH.isDisabled() is False", ltLH.isDisabled());
|
|
Assert.assertFalse("ltWY.isDisabled() is False", ltWY.isDisabled());
|
|
Assert.assertFalse("ltDX.isDisabled() is False", ltDX.isDisabled());
|
|
Assert.assertFalse("ltRX.isDisabled() is False", ltRX.isDisabled());
|
|
Assert.assertFalse("ltLX.isDisabled() is False", ltLX.isDisabled());
|
|
}
|
|
|
|
@Test
|
|
public void testSetDisabled() {
|
|
ltRH.setDisabled(true);
|
|
Assert.assertTrue("ltRH.isDisabled() is True", ltRH.isDisabled());
|
|
ltLH.setDisabled(true);
|
|
Assert.assertTrue("ltLH.isDisabled() is True", ltLH.isDisabled());
|
|
ltWY.setDisabled(true);
|
|
Assert.assertTrue("ltWY.isDisabled() is True", ltWY.isDisabled());
|
|
ltDX.setDisabled(true);
|
|
Assert.assertTrue("ltDX.isDisabled() is True", ltDX.isDisabled());
|
|
ltRX.setDisabled(true);
|
|
Assert.assertTrue("ltRX.isDisabled() is True", ltRX.isDisabled());
|
|
ltLX.setDisabled(true);
|
|
Assert.assertTrue("ltLX.isDisabled() is True", ltLX.isDisabled());
|
|
}
|
|
|
|
@Test
|
|
public void testIsDisabledWhenOccupied() {
|
|
Assert.assertFalse("ltRH.isDisabledWhenOccupied() is False", ltRH.isDisabledWhenOccupied());
|
|
Assert.assertFalse("ltLH.isDisabledWhenOccupied() is False", ltLH.isDisabledWhenOccupied());
|
|
Assert.assertFalse("ltWY.isDisabledWhenOccupied() is False", ltWY.isDisabledWhenOccupied());
|
|
Assert.assertFalse("ltDX.isDisabledWhenOccupied() is False", ltDX.isDisabledWhenOccupied());
|
|
Assert.assertFalse("ltRX.isDisabledWhenOccupied() is False", ltRX.isDisabledWhenOccupied());
|
|
Assert.assertFalse("ltLX.isDisabledWhenOccupied() is False", ltLX.isDisabledWhenOccupied());
|
|
}
|
|
|
|
@Test
|
|
public void testSetDisableWhenOccupied() {
|
|
ltRH.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltRH.isDisabledWhenOccupied() is True", ltRH.isDisabledWhenOccupied());
|
|
ltLH.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltLH.isDisabledWhenOccupied() is True", ltLH.isDisabledWhenOccupied());
|
|
ltWY.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltWY.isDisabledWhenOccupied() is True", ltWY.isDisabledWhenOccupied());
|
|
ltDX.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltDX.isDisabledWhenOccupied() is True", ltDX.isDisabledWhenOccupied());
|
|
ltRX.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltRX.isDisabledWhenOccupied() is True", ltRX.isDisabledWhenOccupied());
|
|
ltLX.setDisableWhenOccupied(true);
|
|
Assert.assertTrue("ltLX.isDisabledWhenOccupied() is True", ltLX.isDisabledWhenOccupied());
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectionInvalid() {
|
|
Assert.assertNotNull("LayoutEditor exists", layoutEditor);
|
|
|
|
try {
|
|
Assert.assertNull("ltRH.getConnection(invalid type) is null",
|
|
ltRH.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltRH.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Right Hand.getConnection(NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
Assert.assertNull("ltLH.getConnection(invalid type) is null",
|
|
ltLH.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltLH.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Left Hand.getConnection(NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
Assert.assertNull("ltWY.getConnection(invalid type) is null",
|
|
ltWY.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltWY.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Wye.getConnection(NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
Assert.assertNull("ltDX.getConnection(invalid type) is null",
|
|
ltDX.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltDX.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Double XOver.getConnection(NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
Assert.assertNull("ltRX.getConnection(invalid type) is null",
|
|
ltRX.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltRX.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Right Hand XOver.getConnection(NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
Assert.assertNull("ltLX.getConnection(invalid type) is null",
|
|
ltLX.getConnection(HitPointType.NONE));
|
|
Assert.fail("No exception thrown on ltLX.getConnection(invalid type)");
|
|
} catch (IllegalArgumentException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Left Hand XOver.getConnection(NONE); Invalid Connection Type");
|
|
}
|
|
|
|
@Test
|
|
public void testGetConnectionValid() {
|
|
Assert.assertNotNull("LayoutEditor exists", layoutEditor);
|
|
|
|
try {
|
|
Assert.assertNull("ltRH.getConnection(valid type) is null",
|
|
ltRH.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltRH.getConnection(valid type)");
|
|
}
|
|
|
|
try {
|
|
Assert.assertNull("ltLH.getConnection(valid type) is null",
|
|
ltLH.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltLH.getConnection(valid type)");
|
|
}
|
|
|
|
try {
|
|
Assert.assertNull("ltWY.getConnection(valid type) is null",
|
|
ltWY.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltWY.getConnection(valid type)");
|
|
}
|
|
|
|
try {
|
|
Assert.assertNull("ltDX.getConnection(valid type) is null",
|
|
ltDX.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltDX.getConnection(valid type)");
|
|
}
|
|
|
|
try {
|
|
Assert.assertNull("ltRX.getConnection(valid type) is null",
|
|
ltRX.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltRX.getConnection(valid type)");
|
|
}
|
|
|
|
try {
|
|
Assert.assertNull("ltLX.getConnection(valid type) is null",
|
|
ltLX.getConnection(HitPointType.TURNOUT_A));
|
|
} catch (IllegalArgumentException ex) {
|
|
Assert.fail("Exception thrown on ltLX.getConnection(valid type)");
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testSetConnection() {
|
|
Assert.assertNotNull("LayoutEditor exists", layoutEditor);
|
|
|
|
try {
|
|
// test Invalid Connection Type
|
|
ltRH.setConnection(HitPointType.NONE, null, HitPointType.NONE);
|
|
Assert.fail("No exception thrown on ltRH.setConnection(Invalid Connection Type)");
|
|
} catch (JmriException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Right Hand.setConnection(NONE, null, NONE); Invalid Connection Type");
|
|
|
|
try {
|
|
// test unexpected type
|
|
ltRH.setConnection(HitPointType.POS_POINT, null, HitPointType.POS_POINT);
|
|
Assert.fail("No exception thrown on ltRH.setConnection(unexpected type)");
|
|
} catch (JmriException ex) {
|
|
}
|
|
JUnitAppender.assertErrorMessage("will throw Right Hand.setConnection(POS_POINT, null, POS_POINT); unexpected type");
|
|
|
|
try {
|
|
// test valid types
|
|
ltRH.setConnection(HitPointType.TURNOUT_A, null, HitPointType.NONE);
|
|
} catch (JmriException ex) {
|
|
Assert.fail("Exception thrown on ltRH.setConnection(valid types)");
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testSetConnectsInvalid() {
|
|
Assert.assertNotNull("LayoutEditor exists", layoutEditor);
|
|
|
|
ltRH.setConnectA(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Right Hand.setConnectA(null, POS_POINT); unexpected type");
|
|
ltRH.setConnectB(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Right Hand.setConnectB(null, POS_POINT); unexpected type");
|
|
ltRH.setConnectC(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Right Hand.setConnectC(null, POS_POINT); unexpected type");
|
|
ltRH.setConnectD(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Right Hand.setConnectD(null, POS_POINT); unexpected type");
|
|
|
|
ltLH.setConnectA(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Left Hand.setConnectA(null, POS_POINT); unexpected type");
|
|
ltLH.setConnectB(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Left Hand.setConnectB(null, POS_POINT); unexpected type");
|
|
ltLH.setConnectC(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Left Hand.setConnectC(null, POS_POINT); unexpected type");
|
|
ltLH.setConnectD(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Left Hand.setConnectD(null, POS_POINT); unexpected type");
|
|
|
|
ltWY.setConnectA(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Wye.setConnectA(null, POS_POINT); unexpected type");
|
|
ltWY.setConnectB(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Wye.setConnectB(null, POS_POINT); unexpected type");
|
|
ltWY.setConnectC(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Wye.setConnectC(null, POS_POINT); unexpected type");
|
|
ltWY.setConnectD(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Wye.setConnectD(null, POS_POINT); unexpected type");
|
|
|
|
ltDX.setConnectA(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Double XOver.setConnectA(null, POS_POINT); unexpected type");
|
|
ltDX.setConnectB(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Double XOver.setConnectB(null, POS_POINT); unexpected type");
|
|
ltDX.setConnectC(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Double XOver.setConnectC(null, POS_POINT); unexpected type");
|
|
ltDX.setConnectD(null, HitPointType.POS_POINT);
|
|
JUnitAppender.assertErrorMessage("Double XOver.setConnectD(null, POS_POINT); unexpected type");
|
|
}
|
|
|
|
@Test
|
|
public void testSetConnectsValid() {
|
|
Assert.assertNotNull("LayoutEditor exists", layoutEditor);
|
|
|
|
ltRH.setConnectA(null, HitPointType.NONE);
|
|
ltLH.setConnectB(null, HitPointType.NONE);
|
|
ltWY.setConnectC(null, HitPointType.NONE);
|
|
ltDX.setConnectD(null, HitPointType.NONE);
|
|
}
|
|
|
|
@Test
|
|
public void testGetStateDefault() {
|
|
assertNotNull( layoutEditor, "LayoutEditor exists");
|
|
|
|
assertEquals(Turnout.UNKNOWN, ltRH.getState(), "ltRH.getState() is UNKNOWN");
|
|
assertEquals(Turnout.UNKNOWN, ltLH.getState(), "ltLH.getState() is UNKNOWN");
|
|
assertEquals(Turnout.UNKNOWN, ltWY.getState(), "ltWY.getState() is UNKNOWN");
|
|
assertEquals(Turnout.UNKNOWN, ltDX.getState(), "ltDX.getState() is UNKNOWN");
|
|
assertEquals(Turnout.UNKNOWN, ltRX.getState(), "ltRX.getState() is UNKNOWN");
|
|
assertEquals(Turnout.UNKNOWN, ltLX.getState(), "ltLX.getState() is UNKNOWN");
|
|
}
|
|
|
|
@Test
|
|
public void testSupportingTurnoutTwoSensor() throws JmriException {
|
|
|
|
Turnout tOne = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("IT1");
|
|
Turnout tTwo = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("IT2");
|
|
Assert.assertNotNull("exists", tOne);
|
|
Assert.assertNotNull("exists", tTwo);
|
|
|
|
Sensor t1Closed = InstanceManager.getDefault(SensorManager.class).provideSensor("IST1Closed");
|
|
Sensor t1Thrown = InstanceManager.getDefault(SensorManager.class).provideSensor("IST1Thrown");
|
|
Sensor t2Closed = InstanceManager.getDefault(SensorManager.class).provideSensor("IST2Closed");
|
|
Sensor t2Thrown = InstanceManager.getDefault(SensorManager.class).provideSensor("IST2Thrown");
|
|
|
|
tOne.provideFirstFeedbackSensor("IST1Thrown");
|
|
tOne.provideSecondFeedbackSensor("IST1Closed");
|
|
tOne.setFeedbackMode(Turnout.TWOSENSOR);
|
|
|
|
tTwo.provideFirstFeedbackSensor("IST2Thrown");
|
|
tTwo.provideSecondFeedbackSensor("IST2Closed");
|
|
tTwo.setFeedbackMode(Turnout.TWOSENSOR);
|
|
|
|
int start1Listeners = tOne.getPropertyChangeListeners().length;
|
|
int start2Listeners = tTwo.getPropertyChangeListeners().length;
|
|
|
|
// not a test of using a String to set the Turnout
|
|
ltRX.setTurnout("IT1");
|
|
ltRX.setSecondTurnout("IT2");
|
|
|
|
Assert.assertEquals("t1 +1 listeners ", start1Listeners + 1, tOne.getPropertyChangeListeners().length);
|
|
Assert.assertEquals("t2 +1 listeners", start2Listeners + 1, tTwo.getPropertyChangeListeners().length);
|
|
|
|
// not a test on the actual bean name, just that one is retrievable
|
|
Assert.assertEquals("tOne name fetchable", tOne.getDisplayName(), ltRX.getTurnoutName());
|
|
Assert.assertEquals("tTwo name fetchable", tTwo.getDisplayName(), ltRX.getSecondTurnoutName());
|
|
|
|
assertEquals(Turnout.UNKNOWN, ltRX.getState(), "0 sensor states known getState UNKNOWN");
|
|
|
|
t1Closed.setKnownState(Sensor.ACTIVE);
|
|
assertEquals(Turnout.INCONSISTENT, ltRX.getState(), "only 1 sensor known INCONSISTENT");
|
|
|
|
t1Thrown.setKnownState(Sensor.INACTIVE);
|
|
assertEquals(Turnout.INCONSISTENT, ltRX.getState(), "only 2 sensor known INCONSISTENT");
|
|
assertEquals(Turnout.CLOSED, tOne.getState(), "main turnout known ");
|
|
|
|
t2Closed.setKnownState(Sensor.ACTIVE);
|
|
assertEquals(Turnout.INCONSISTENT, ltRX.getState(), "only 3 sensor known INCONSISTENT");
|
|
|
|
t2Thrown.setKnownState(Sensor.INACTIVE);
|
|
Assert.assertEquals("t1 CLOSED", Turnout.CLOSED, tOne.getState());
|
|
Assert.assertEquals("t2 CLOSED", Turnout.CLOSED, tTwo.getState());
|
|
Assert.assertEquals("both turnouts CLOSED", Turnout.CLOSED, ltRX.getState());
|
|
|
|
t2Closed.setKnownState(Sensor.INACTIVE);
|
|
assertEquals(Turnout.INCONSISTENT, ltRX.getState(), "t2 leg status INCONSISTENT");
|
|
t2Thrown.setKnownState(Sensor.ACTIVE);
|
|
Assert.assertEquals("t2 THROWN", Turnout.THROWN, tTwo.getState());
|
|
assertEquals(Turnout.INCONSISTENT, ltRX.getState(), "t2 THROWN t1 CLOSED INCONSISTENT");
|
|
|
|
// remove turnouts and check num listeners
|
|
ltRX.setSecondTurnout("");
|
|
Assert.assertEquals("t1 +1 listeners ", start1Listeners + 1, tOne.getPropertyChangeListeners().length);
|
|
Assert.assertEquals("t2 start listeners", start2Listeners, tTwo.getPropertyChangeListeners().length);
|
|
|
|
ltRX.setTurnout("");
|
|
Assert.assertEquals("t1 start listeners ", start1Listeners, tOne.getPropertyChangeListeners().length);
|
|
|
|
tOne.dispose();
|
|
tTwo.dispose();
|
|
|
|
t1Closed.dispose();
|
|
t1Thrown.dispose();
|
|
|
|
t2Closed.dispose();
|
|
t2Thrown.dispose();
|
|
}
|
|
|
|
@Test
|
|
public void testSupportingTurnoutLogic() throws JmriException {
|
|
|
|
Turnout stOne = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITS1");
|
|
Turnout stTwo = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITS2");
|
|
|
|
// not a test of using a String to set the Turnout
|
|
ltRX.setTurnout("ITS1");
|
|
ltRX.setSecondTurnout("ITS2");
|
|
|
|
Assert.assertFalse(ltRX.isSecondTurnoutInverted());
|
|
|
|
ltRX.setSecondTurnoutInverted(true);
|
|
Assert.assertTrue(ltRX.isSecondTurnoutInverted());
|
|
|
|
// Here we're testing the commanded state logic that joins the Turnouts when operated,
|
|
// the actual LayoutTurnout status is dependent on the feedback status.
|
|
Assert.assertEquals("t2 inverted CLOSED when t1 THROWN", Turnout.UNKNOWN, stTwo.getCommandedState());
|
|
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
Assert.assertEquals("ltRX UNKNOWN", Turnout.UNKNOWN, ltRX.getState());
|
|
stOne.setCommandedState(Turnout.THROWN);
|
|
Assert.assertEquals("t2 inverted CLOSED when t1 THROWN", Turnout.CLOSED, stTwo.getCommandedState());
|
|
Assert.assertEquals("ltRX THROWN", Turnout.THROWN, ltRX.getState());
|
|
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.CLOSED);
|
|
Assert.assertEquals("t2 inverted THROWN when t1 CLOSED", Turnout.THROWN, stTwo.getCommandedState());
|
|
Assert.assertEquals("ltRX CLOSED", Turnout.CLOSED, ltRX.getState());
|
|
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.THROWN);
|
|
Assert.assertEquals("t1 inverted CLOSED when t2 THROWN", Turnout.CLOSED, stOne.getCommandedState());
|
|
Assert.assertEquals("ltRX CLOSED", Turnout.CLOSED, ltRX.getState());
|
|
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.CLOSED);
|
|
Assert.assertEquals("t1 inverted THROWN when t2 CLOSED", Turnout.THROWN, stOne.getCommandedState());
|
|
Assert.assertEquals("ltRX THROWN", Turnout.THROWN, ltRX.getState());
|
|
|
|
ltRX.setSecondTurnoutInverted(false);
|
|
Assert.assertFalse(ltRX.isSecondTurnoutInverted());
|
|
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.THROWN);
|
|
Assert.assertEquals("t2 THROWN when t1 THROWN", Turnout.THROWN, stTwo.getCommandedState());
|
|
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.CLOSED);
|
|
Assert.assertEquals("t2 CLOSED when t1 CLOSED", Turnout.CLOSED, stTwo.getCommandedState());
|
|
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.THROWN);
|
|
Assert.assertEquals("t1 THROWN when t2 THROWN", Turnout.THROWN, stOne.getCommandedState());
|
|
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.CLOSED);
|
|
Assert.assertEquals("t1 CLOSED when t2 CLOSED", Turnout.CLOSED, stOne.getCommandedState());
|
|
|
|
stOne.dispose();
|
|
stTwo.dispose();
|
|
}
|
|
|
|
@Test
|
|
public void testThrowWhenOccupiedOneTurnout() throws JmriException {
|
|
|
|
Assert.assertEquals("ltRH starts unknown state", Turnout.UNKNOWN, ltRH.getState());
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("no change null Turnout", Turnout.UNKNOWN, ltRH.getState());
|
|
|
|
ltRH.setDisabled(true);
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("no change null Turnout and disabled", Turnout.UNKNOWN, ltRH.getState());
|
|
|
|
Turnout otOne = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITS1");
|
|
ltRH.setTurnout("ITS1");
|
|
otOne.setCommandedState(Turnout.UNKNOWN);
|
|
Assert.assertEquals("turnout set ", Turnout.UNKNOWN, otOne.getState());
|
|
Assert.assertEquals("turnout set ", Turnout.UNKNOWN, ltRH.getState());
|
|
|
|
ltRH.setDisabled(true);
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("turnout still UNKNOWN after set CLOSE disabled", Turnout.UNKNOWN, ltRH.getState());
|
|
ltRH.setDisabled(false);
|
|
|
|
LayoutBlock layoutBlock = new LayoutBlock("ILB1", "Test Block");
|
|
Sensor occSensor = InstanceManager.getDefault(SensorManager.class).provideSensor("ISOccupancy1");
|
|
occSensor.setKnownState(Sensor.ACTIVE);
|
|
layoutBlock.setOccupancySensorName("ISOccupancy1");
|
|
assertEquals(LayoutBlock.OCCUPIED, layoutBlock.getOccupancy(), "Occupied when sensor active");
|
|
|
|
ltRHv.setLayoutBlock(layoutBlock);
|
|
|
|
// occupied, occ. active disabled
|
|
ltRH.setDisableWhenOccupied(false);
|
|
occSensor.setKnownState(Sensor.ACTIVE);
|
|
otOne.setCommandedState(Turnout.UNKNOWN);
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("ltRH CLOSED when occupied, occ when active not disabled", Turnout.CLOSED, otOne.getCommandedState());
|
|
ltRH.setState(Turnout.THROWN);
|
|
Assert.assertEquals("ltRH THROWN when occupied, occ when active not disabled", Turnout.THROWN, otOne.getCommandedState());
|
|
|
|
// occupied, occ. active enabled
|
|
ltRH.setDisableWhenOccupied(true);
|
|
occSensor.setKnownState(Sensor.ACTIVE);
|
|
otOne.setCommandedState(Turnout.UNKNOWN);
|
|
ltRH.setState(Turnout.THROWN);
|
|
Assert.assertEquals("ltRH unchanged when occupied, occ when active enabled", Turnout.UNKNOWN, ltRH.getState());
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("ltRH unchanged when occupied, occ when active enabled", Turnout.UNKNOWN, ltRH.getState());
|
|
|
|
// not occupied, occ. active disabled
|
|
ltRH.setDisableWhenOccupied(false);
|
|
occSensor.setKnownState(Sensor.INACTIVE);
|
|
otOne.setCommandedState(Turnout.UNKNOWN);
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("ltRH CLOSED when occupied, occ when active not disabled", Turnout.CLOSED, otOne.getCommandedState());
|
|
ltRH.setState(Turnout.THROWN);
|
|
Assert.assertEquals("ltRH THROWN when occupied, occ when active not disabled", Turnout.THROWN, otOne.getCommandedState());
|
|
|
|
// not occupied, occ. active enabled
|
|
ltRH.setDisableWhenOccupied(true);
|
|
occSensor.setKnownState(Sensor.INACTIVE);
|
|
otOne.setCommandedState(Turnout.UNKNOWN);
|
|
ltRH.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("ltRH CLOSED when occupied, occ when active not disabled", Turnout.CLOSED, otOne.getCommandedState());
|
|
ltRH.setState(Turnout.THROWN);
|
|
Assert.assertEquals("ltRH THROWN when occupied, occ when active not disabled", Turnout.THROWN, otOne.getCommandedState());
|
|
|
|
layoutBlock.dispose();
|
|
otOne.dispose();
|
|
}
|
|
|
|
@Test
|
|
public void testSecondaryTurnoutStateWhenSet() throws JmriException {
|
|
|
|
// not testing occupancy as that was covered in previous test
|
|
Turnout stOne = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITS1");
|
|
Turnout stTwo = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITS2");
|
|
|
|
// not a test of using a String to set the Turnout
|
|
ltRX.setTurnout("ITS1");
|
|
ltRX.setSecondTurnout("ITS2");
|
|
|
|
ltRX.setSecondTurnoutInverted(false);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
ltRX.setState(Turnout.THROWN);
|
|
Assert.assertEquals("StOne THROWN", Turnout.THROWN, stOne.getCommandedState());
|
|
Assert.assertEquals("StTwo THROWN", Turnout.THROWN, stTwo.getCommandedState());
|
|
|
|
ltRX.setSecondTurnoutInverted(false);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
ltRX.setState(Turnout.THROWN);
|
|
Assert.assertEquals("StOne THROWN", Turnout.THROWN, stOne.getCommandedState());
|
|
Assert.assertEquals("StTwo THROWN", Turnout.THROWN, stTwo.getCommandedState());
|
|
|
|
ltRX.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("StOne CLOSED", Turnout.CLOSED, stOne.getCommandedState());
|
|
Assert.assertEquals("StTwo CLOSED", Turnout.CLOSED, stTwo.getCommandedState());
|
|
|
|
ltRX.setSecondTurnoutInverted(true);
|
|
stOne.setCommandedState(Turnout.UNKNOWN);
|
|
stTwo.setCommandedState(Turnout.UNKNOWN);
|
|
ltRX.setState(Turnout.THROWN);
|
|
Assert.assertEquals("StOne THROWN", Turnout.THROWN, stOne.getCommandedState());
|
|
Assert.assertEquals("StTwo CLOSED", Turnout.CLOSED, stTwo.getCommandedState());
|
|
|
|
ltRX.setState(Turnout.CLOSED);
|
|
Assert.assertEquals("StOne CLOSED", Turnout.CLOSED, stOne.getCommandedState());
|
|
Assert.assertEquals("StTwo THROWN", Turnout.THROWN, stTwo.getCommandedState());
|
|
}
|
|
|
|
@Test
|
|
public void testToggle() throws JmriException {
|
|
|
|
// null Turnout
|
|
Assert.assertEquals("starts UNKNOWN", Turnout.UNKNOWN, ltRH.getState());
|
|
ltRH.toggleTurnout();
|
|
Assert.assertEquals("still UNKNOWN no Turnout to toggle", Turnout.UNKNOWN, ltRH.getState());
|
|
|
|
Turnout ptOne = InstanceManager.getDefault(TurnoutManager.class).provideTurnout("ITP1");
|
|
ltRH.setTurnout("ITP1");
|
|
|
|
ptOne.setCommandedState(Turnout.UNKNOWN);
|
|
ltRH.toggleTurnout();
|
|
Assert.assertEquals("UNKNOWN to CLOSED when toggled", Turnout.CLOSED, ptOne.getCommandedState());
|
|
|
|
ltRH.toggleTurnout();
|
|
Assert.assertEquals("CLOSED to THROWN when toggled", Turnout.THROWN, ptOne.getCommandedState());
|
|
|
|
ltRH.toggleTurnout();
|
|
Assert.assertEquals("THROWN to CLOSED when toggled", Turnout.CLOSED, ptOne.getCommandedState());
|
|
}
|
|
|
|
private LayoutRHTurnout ltRH = null;
|
|
private LayoutRHTurnoutView ltRHv = null;
|
|
|
|
private LayoutLHTurnout ltLH = null;
|
|
private LayoutLHTurnoutView ltLHv = null;
|
|
|
|
private LayoutWye ltWY = null;
|
|
private LayoutWyeView ltWYv = null;
|
|
|
|
private LayoutDoubleXOver ltDX = null;
|
|
private LayoutDoubleXOverView ltDXv = null;
|
|
|
|
private LayoutRHXOver ltRX = null;
|
|
private LayoutRHXOverView ltRXv = null;
|
|
|
|
private LayoutLHXOver ltLX = null;
|
|
private LayoutLHXOverView ltLXv = null;
|
|
|
|
@Override
|
|
@BeforeEach
|
|
@javax.annotation.OverridingMethodsMustInvokeSuper
|
|
public void setUp() {
|
|
super.setUp();
|
|
|
|
JUnitUtil.resetInstanceManager();
|
|
JUnitUtil.resetProfileManager();
|
|
JUnitUtil.initInternalTurnoutManager();
|
|
JUnitUtil.initInternalSensorManager();
|
|
JUnitUtil.initInternalSignalHeadManager();
|
|
|
|
Point2D point = new Point2D.Double(150.0, 100.0);
|
|
Point2D delta = new Point2D.Double(50.0, 75.0);
|
|
|
|
ltRH = new LayoutRHTurnout("Right Hand", layoutEditor); // point, 33.0, 1.1, 1.2,
|
|
ltRHv = new LayoutRHTurnoutView(ltRH, point, 33.0, 1.1, 1.2, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltRH, ltRHv);
|
|
|
|
point = MathUtil.add(point, delta);
|
|
ltLH = new LayoutLHTurnout("Left Hand", layoutEditor); // point, 66.0, 1.3, 1.4,
|
|
ltLHv = new LayoutLHTurnoutView(ltLH, point, 66.0, 1.3, 1.4, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltLH, ltLHv);
|
|
|
|
point = MathUtil.add(point, delta);
|
|
ltWY = new LayoutWye("Wye", layoutEditor); // point, 99.0, 1.5, 1.6,
|
|
ltWYv = new LayoutWyeView(ltWY, point, 99.0, 1.5, 1.6, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltWY, ltWYv);
|
|
|
|
point = MathUtil.add(point, delta);
|
|
ltDX = new LayoutDoubleXOver("Double XOver", layoutEditor); // point, 132.0, 1.7, 1.8,
|
|
ltDXv = new LayoutDoubleXOverView(ltDX, point, 132.0, 1.7, 1.8, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltDX, ltDXv);
|
|
|
|
point = MathUtil.add(point, delta);
|
|
ltRX = new LayoutRHXOver("Right Hand XOver", layoutEditor); // point, 165.0, 1.9, 2.0,
|
|
ltRXv = new LayoutRHXOverView(ltRX, point, 165.0, 1.9, 2.0, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltRX, ltRXv);
|
|
|
|
point = MathUtil.add(point, delta);
|
|
ltLX = new LayoutLHXOver("Left Hand XOver", layoutEditor); // point, 198.0, 2.1, 2.2,
|
|
ltLXv = new LayoutLHXOverView(ltLX, point, 198.0, 2.1, 2.2, layoutEditor);
|
|
layoutEditor.addLayoutTrack(ltLX, ltLXv);
|
|
|
|
}
|
|
|
|
@Override
|
|
@AfterEach
|
|
@javax.annotation.OverridingMethodsMustInvokeSuper
|
|
public void tearDown() {
|
|
if (ltRH != null) {
|
|
ltRH.remove();
|
|
ltRH = null;
|
|
}
|
|
if (ltRHv != null) {
|
|
ltRHv.remove();
|
|
ltRHv.dispose();
|
|
ltRHv = null;
|
|
}
|
|
|
|
if (ltLH != null) {
|
|
ltLH.remove();
|
|
ltLH = null;
|
|
}
|
|
if (ltLHv != null) {
|
|
ltLHv.remove();
|
|
ltLHv.dispose();
|
|
ltLHv = null;
|
|
}
|
|
|
|
if (ltWY != null) {
|
|
ltWY.remove();
|
|
ltWY = null;
|
|
}
|
|
if (ltWYv != null) {
|
|
ltWYv.remove();
|
|
ltWYv.dispose();
|
|
ltWYv = null;
|
|
}
|
|
|
|
if (ltDX != null) {
|
|
ltDX.remove();
|
|
ltDX = null;
|
|
}
|
|
if (ltDXv != null) {
|
|
ltDXv.remove();
|
|
ltDXv.dispose();
|
|
ltDXv = null;
|
|
}
|
|
|
|
if (ltRX != null) {
|
|
ltRX.remove();
|
|
ltRX = null;
|
|
}
|
|
if (ltRXv != null) {
|
|
ltRXv.remove();
|
|
ltRXv.dispose();
|
|
ltRXv = null;
|
|
}
|
|
|
|
if (ltLX != null) {
|
|
ltLX.remove();
|
|
ltLX = null;
|
|
}
|
|
if (ltLXv != null) {
|
|
ltLXv.remove();
|
|
ltLXv.dispose();
|
|
ltLXv = null;
|
|
}
|
|
|
|
super.tearDown();
|
|
}
|
|
|
|
// private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LayoutTurnoutTest.class);
|
|
}
|