Serge NOEL
813 lines
32 KiB
Java
813 lines
32 KiB
Java
package jmri;
|
|
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
|
|
import java.util.Collections;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import jmri.implementation.SignalSpeedMap;
|
|
import jmri.jmrix.internal.InternalSensorManager;
|
|
import jmri.jmrix.internal.InternalSystemConnectionMemo;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
|
|
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.assertTrue;
|
|
|
|
/**
|
|
* Tests for the Block class
|
|
*
|
|
* @author Bob Jacobsen Copyright (C) 2006
|
|
*/
|
|
public class BlockTest {
|
|
|
|
/**
|
|
* Normally, users create Block objects via a manager, but we test the
|
|
* direct create here. If it works, we can use it for testing.
|
|
*/
|
|
@Test
|
|
public void testDirectCreate() {
|
|
Block b = new Block("SystemName");
|
|
assertNotNull( b, "Block Created");
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings({"unlikely-arg-type", "ObjectEqualsNull", "IncompatibleEquals"}) // String / StringBuffer seems to be unrelated to Block
|
|
public void testEquals() {
|
|
Block b1 = new Block("SystemName1");
|
|
Block b2 = new Block("SystemName2");
|
|
|
|
//multiple Block objects with same SystemName are really the same
|
|
Block b1a = new Block("SystemName1");
|
|
|
|
assertTrue(b1.equals(b1)); // identity
|
|
assertFalse(b1.equals(b2)); // blocks are named objects
|
|
|
|
assertTrue(b1a.equals(b1));
|
|
assertTrue(b1.equals(b1a)); // commutes
|
|
|
|
// check null
|
|
assertFalse(b1.equals(null));
|
|
|
|
// check another type
|
|
assertFalse(b1.equals(new StringBuffer("foo")));
|
|
assertFalse(b1.equals("foo"));
|
|
}
|
|
|
|
@Test
|
|
public void testBlockHashCode() {
|
|
Block b1 = new Block("SystemName1");
|
|
|
|
//multiple Block objects with same SystemName are really the same
|
|
Block b1a = new Block("SystemName1");
|
|
|
|
assertTrue(b1.hashCode() == b1a.hashCode());
|
|
|
|
b1a.setLength(120);
|
|
b1a.setCurvature(21);
|
|
assertTrue(b1.hashCode() == b1a.hashCode());
|
|
}
|
|
|
|
@Test
|
|
public void testSensorAdd() {
|
|
Block b = new Block("SystemName");
|
|
b.setSensor("IS12");
|
|
}
|
|
|
|
private int count;
|
|
|
|
@Test
|
|
public void testSensorInvoke() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
count = 0;
|
|
Block b = new Block("SystemName") {
|
|
@Override
|
|
void handleSensorChange(java.beans.PropertyChangeEvent e) {
|
|
count++;
|
|
}
|
|
};
|
|
Sensor s = sm.provideSensor("IS12");
|
|
b.setNamedSensor(jmri.InstanceManager.getDefault(jmri.NamedBeanHandleManager.class).getNamedBeanHandle("IS12", s));
|
|
sm.provideSensor("IS12").setState(jmri.Sensor.ACTIVE);
|
|
assertEquals( 1, count, "count of detected changes");
|
|
}
|
|
|
|
@Test
|
|
public void testValueField() {
|
|
Block b = new Block("SystemName");
|
|
b.setValue("string");
|
|
assertEquals( "string", b.getValue(), "Returned Object matches");
|
|
}
|
|
|
|
@Test
|
|
public void testSensorSequence() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
count = 0;
|
|
Block b = new Block("SystemName");
|
|
Sensor s = sm.provideSensor("IS12");
|
|
s.setState(Sensor.UNKNOWN);
|
|
|
|
assertEquals( Block.UNDETECTED, b.getState(), "Initial state"); // state until sensor is set
|
|
|
|
b.setSensor("IS12");
|
|
s.setState(Sensor.ACTIVE);
|
|
assertEquals( Block.OCCUPIED, s.getState(), "State with sensor active");
|
|
s.setState(Sensor.INACTIVE);
|
|
assertEquals( Block.UNOCCUPIED, s.getState(), "State with sensor inactive");
|
|
}
|
|
|
|
@Test
|
|
public void testCoding() {
|
|
assertTrue( Block.OCCUPIED != Block.UNOCCUPIED, "Block.OCCUPIED != Block.UNOCCUPIED");
|
|
assertTrue( Block.OCCUPIED != Block.UNDETECTED, "Block.OCCUPIED != Block.UNDETECTED");
|
|
assertTrue( Block.OCCUPIED != Block.UNKNOWN, "Block.OCCUPIED != Block.UNKNOWN");
|
|
assertTrue( Block.OCCUPIED != Block.INCONSISTENT, "Block.OCCUPIED != Block.INCONSISTENT");
|
|
assertTrue( Block.UNOCCUPIED != Block.UNDETECTED, "Block.UNOCCUPIED != Block.UNDETECTED");
|
|
assertTrue( Block.UNOCCUPIED != Block.UNKNOWN, "Block.UNOCCUPIED != Block.UNKNOWN");
|
|
assertTrue( Block.UNOCCUPIED != Block.INCONSISTENT, "Block.UNOCCUPIED != Block.INCONSISTENT");
|
|
assertTrue( Block.UNDETECTED != Block.UNKNOWN, "Block.UNDETECTED != Block.UNKNOWN");
|
|
assertTrue( Block.UNDETECTED != Block.INCONSISTENT, "Block.UNDETECTED != Block.INCONSISTENT");
|
|
assertTrue( Block.UNKNOWN != Block.INCONSISTENT, "Block.UNKNOWN != Block.INCONSISTENT");
|
|
}
|
|
|
|
// test going active with only one neighbor
|
|
@Test
|
|
public void testFirstGoActive() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
|
|
Block b1 = new Block("SystemName1");
|
|
|
|
Block b2 = new Block("SystemName2");
|
|
Sensor s2 = sm.provideSensor("IS2");
|
|
b2.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS2", s2));
|
|
s2.setState(Sensor.ACTIVE);
|
|
b2.setValue("b2 contents");
|
|
|
|
Path p = new Path();
|
|
p.setBlock(b2);
|
|
|
|
b1.addPath(p);
|
|
|
|
// actual test
|
|
b1.goingActive();
|
|
assertEquals( "b2 contents", b1.getValue(), "Value transferred");
|
|
}
|
|
|
|
// Test going active with two neighbors, one active.
|
|
// b2 is between b1 and b3. b1 contains a train
|
|
@Test
|
|
public void testOneOfTwoGoesActive() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
|
|
Block b1 = new Block("SystemName1");
|
|
Block b2 = new Block("SystemName2");
|
|
Block b3 = new Block("SystemName3");
|
|
|
|
Sensor s1 = sm.provideSensor("IS1");
|
|
b1.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS1", s1));
|
|
s1.setState(Sensor.ACTIVE);
|
|
b1.setValue("b1 contents");
|
|
|
|
Sensor s2 = sm.provideSensor("IS2");
|
|
b2.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS2", s2));
|
|
s2.setState(Sensor.INACTIVE);
|
|
|
|
Sensor s3 = sm.provideSensor("IS3");
|
|
b3.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS3", s3));
|
|
s3.setState(Sensor.INACTIVE);
|
|
|
|
Path p21 = new Path();
|
|
p21.setBlock(b1);
|
|
p21.setFromBlockDirection(Path.RIGHT);
|
|
p21.setToBlockDirection(Path.LEFT);
|
|
b2.addPath(p21);
|
|
|
|
Path p23 = new Path();
|
|
p23.setBlock(b3);
|
|
p23.setFromBlockDirection(Path.LEFT);
|
|
p23.setToBlockDirection(Path.RIGHT);
|
|
b2.addPath(p23);
|
|
|
|
// actual test
|
|
b2.goingActive();
|
|
assertEquals( Block.OCCUPIED, b2.getState(), "State");
|
|
assertEquals( "b1 contents", b2.getValue(), "Value transferred");
|
|
assertEquals( Path.RIGHT, b2.getDirection(), "Direction");
|
|
|
|
}
|
|
|
|
// Test going active with two neighbors, both active.
|
|
// b2 is between b1 and b3.
|
|
@Test
|
|
public void testTwoOfTwoGoesActive() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
|
|
Block b1 = new Block("SystemName1");
|
|
Block b2 = new Block("SystemName2");
|
|
Block b3 = new Block("SystemName3");
|
|
|
|
Sensor s1 = sm.provideSensor("IS1");
|
|
b1.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS1", s1));
|
|
s1.setState(Sensor.ACTIVE);
|
|
b1.setValue("b1 contents");
|
|
b1.setDirection(Path.RIGHT);
|
|
|
|
Sensor s2 = sm.provideSensor("IS2");
|
|
b2.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS2", s2));
|
|
s2.setState(Sensor.INACTIVE);
|
|
|
|
Sensor s3 = sm.provideSensor("IS3");
|
|
b3.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS3", s3));
|
|
s3.setState(Sensor.ACTIVE);
|
|
b3.setValue("b3 contents");
|
|
b3.setDirection(Path.RIGHT);
|
|
|
|
Path p21 = new Path();
|
|
p21.setBlock(b1);
|
|
p21.setFromBlockDirection(Path.RIGHT);
|
|
p21.setToBlockDirection(Path.LEFT);
|
|
b2.addPath(p21);
|
|
|
|
Path p23 = new Path();
|
|
p23.setBlock(b3);
|
|
p23.setFromBlockDirection(Path.LEFT);
|
|
p23.setToBlockDirection(Path.RIGHT);
|
|
b2.addPath(p23);
|
|
|
|
// actual test
|
|
b2.goingActive();
|
|
assertEquals( Block.OCCUPIED, b2.getState(), "State");
|
|
assertEquals( "b1 contents", b2.getValue(), "Value transferred");
|
|
assertEquals( Path.RIGHT, b2.getDirection(), "Direction");
|
|
|
|
}
|
|
|
|
// Test going active with two neighbors, both active, where FROM is a combination direction.
|
|
// b2 is between b1 and b3.
|
|
@Test
|
|
public void testTwoOfTwoGoesActiveCombination() throws JmriException {
|
|
SensorManager sm = new InternalSensorManager(InstanceManager.getDefault(InternalSystemConnectionMemo.class));
|
|
|
|
Block b1 = new Block("SystemName1");
|
|
Block b2 = new Block("SystemName2");
|
|
Block b3 = new Block("SystemName3");
|
|
|
|
Sensor s1 = sm.provideSensor("IS1");
|
|
b1.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS1", s1));
|
|
s1.setState(Sensor.ACTIVE);
|
|
b1.setValue("b1 contents");
|
|
b1.setDirection(Path.NORTH_WEST); //combination direction
|
|
|
|
Sensor s2 = sm.provideSensor("IS2");
|
|
b2.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS2", s2));
|
|
s2.setState(Sensor.INACTIVE);
|
|
|
|
Sensor s3 = sm.provideSensor("IS3");
|
|
b3.setNamedSensor(InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle("IS3", s3));
|
|
s3.setState(Sensor.ACTIVE);
|
|
b3.setValue("b3 contents");
|
|
b3.setDirection(Path.NORTH);
|
|
|
|
Path p21 = new Path();
|
|
p21.setBlock(b1);
|
|
p21.setFromBlockDirection(Path.NORTH);
|
|
p21.setToBlockDirection(Path.SOUTH);
|
|
b2.addPath(p21);
|
|
|
|
Path p23 = new Path();
|
|
p23.setBlock(b3);
|
|
p23.setFromBlockDirection(Path.EAST);
|
|
p23.setToBlockDirection(Path.NORTH);
|
|
b2.addPath(p23);
|
|
|
|
// actual test
|
|
b2.goingActive();
|
|
assertEquals( Block.OCCUPIED, b2.getState(), "State");
|
|
assertEquals( "b1 contents", b2.getValue(), "Value transferred");
|
|
assertEquals( Path.NORTH, b2.getDirection(), "Direction");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testReporterAdd() {
|
|
ReporterManager rm = jmri.InstanceManager.getDefault(ReporterManager.class);
|
|
Block b = new Block("SystemName");
|
|
b.setReporter(rm.provideReporter("IR22"));
|
|
}
|
|
|
|
@Test
|
|
public void testReporterInvokeAll() {
|
|
ReporterManager rm = jmri.InstanceManager.getDefault(ReporterManager.class);
|
|
count = 0;
|
|
Block b = new Block("SystemName") {
|
|
@Override
|
|
void handleReporterChange(java.beans.PropertyChangeEvent e) {
|
|
count++;
|
|
}
|
|
};
|
|
b.setReporter(rm.provideReporter("IR22"));
|
|
rm.provideReporter("IR22").setReport("report");
|
|
// For each report, there are two PropertyChangeEvents -
|
|
// "currentReport" and "lastReport"
|
|
assertEquals( 2, count, "count of detected changes");
|
|
}
|
|
|
|
@Test
|
|
public void testReporterInvokeCurrent() {
|
|
ReporterManager rm = InstanceManager.getDefault(ReporterManager.class);
|
|
count = 0;
|
|
Block b = new Block("SystemName") {
|
|
@Override
|
|
void handleReporterChange(java.beans.PropertyChangeEvent e) {
|
|
if (e.getPropertyName().equals("currentReport")) {
|
|
count++;
|
|
}
|
|
}
|
|
};
|
|
b.setReporter(rm.provideReporter("IR22"));
|
|
rm.provideReporter("IR22").setReport("report");
|
|
// Only detecting "currentReport" PropertyChangeEvent
|
|
assertEquals( 1, count, "count of detected changes");
|
|
|
|
rm.provideReporter("IR22").setReport(null);
|
|
// Current report should change
|
|
assertEquals( 2, count, "count of detected changes");
|
|
}
|
|
|
|
@Test
|
|
public void testReporterInvokeLast() {
|
|
ReporterManager rm = InstanceManager.getDefault(ReporterManager.class);
|
|
count = 0;
|
|
Block b = new Block("SystemName") {
|
|
@Override
|
|
void handleReporterChange(java.beans.PropertyChangeEvent e) {
|
|
if (e.getPropertyName().equals("lastReport")) {
|
|
count++;
|
|
}
|
|
}
|
|
};
|
|
b.setReporter(rm.provideReporter("IR22"));
|
|
rm.provideReporter("IR22").setReport("report");
|
|
// Only detecting "lastReport" PropertyChangeEvent
|
|
assertEquals( 1, count, "count of detected changes");
|
|
|
|
rm.provideReporter("IR22").setReport(null);
|
|
// Last report should not change
|
|
assertEquals( 1, count, "count of detected changes");
|
|
}
|
|
|
|
@Test
|
|
public void testGetLocoAddress(){
|
|
Block b = new Block("SystemName");
|
|
assertEquals( new DccLocoAddress(1234,LocoAddress.Protocol.DCC), b.getLocoAddress("1234 enter"),
|
|
"address");
|
|
}
|
|
|
|
@Test
|
|
public void testGetLocoDirection(){
|
|
Block b = new Block("SystemName");
|
|
assertEquals( jmri.PhysicalLocationReporter.Direction.ENTER, b.getDirection("1234 enter"),
|
|
"direction");
|
|
}
|
|
|
|
@Test
|
|
public void testAddRemoveListener() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
b.setUserName("Start user id");
|
|
Listen listen = new Listen();
|
|
assertEquals( 0, b.getNumPropertyChangeListeners(), "no listener at start of test");
|
|
|
|
b.addPropertyChangeListener(listen);
|
|
assertEquals( 1, b.getNumPropertyChangeListeners(), "1 listener added");
|
|
|
|
b.setUserName("user id");
|
|
assertEquals( "UserName", listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( "Start user id", listen.getOldValue(0), "old value");
|
|
assertEquals( "user id", listen.getNewValue(0), "new value");
|
|
|
|
b.removePropertyChangeListener(listen);
|
|
assertEquals( 0, b.getNumPropertyChangeListeners(), "listener removed");
|
|
|
|
b.setUserName("Changed user id");
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
}
|
|
|
|
|
|
/**
|
|
* Test Property Changes for Adding Sensors to a block.
|
|
*
|
|
* Add a Sensor with UNKNOWN state to Block.
|
|
* Prop change for Block state UNDETECTED to UNKNOWN
|
|
* Prop Change Block added Sensor
|
|
*
|
|
* Change the Block Sensor to new Sensor with INACTIVE state
|
|
* Prop change for Block state UNKNOWN to UNOCCUPIED
|
|
* Prop Change Block Sensor change
|
|
*
|
|
* Remove the Block Sensor
|
|
* Prop change for Block state UNOCCUPIED to UNDETECED
|
|
* Prop Change Block Sensor change
|
|
*
|
|
* @throws JmriException on test error.
|
|
*/
|
|
@Test
|
|
public void testAddSensorPropertyChange() throws JmriException {
|
|
|
|
SensorManager sm = InstanceManager.getDefault(SensorManager.class);
|
|
Sensor sensorUnknownState = sm.provide("ISunknownState");
|
|
sensorUnknownState.setKnownState(Sensor.UNKNOWN);
|
|
|
|
Sensor sensorInactiveState = sm.provide("ISInactiveState");
|
|
sensorInactiveState.setKnownState(Sensor.INACTIVE);
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
assertEquals( Block.UNDETECTED, b.getState(), "Block starts state undetected");
|
|
assertNull( b.getSensor(), "Block starts no sensor");
|
|
Listen listen = new Listen();
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setSensor(null);
|
|
assertEquals( 0, listen.getNumPropChanges(), "no prop change null to null");
|
|
|
|
b.setSensor("");
|
|
assertEquals( 0, listen.getNumPropChanges(), "no prop change null to empty");
|
|
|
|
b.setSensor("ISunknownState");
|
|
assertEquals( 2, listen.getNumPropChanges(), "list size +2, state change, occ sense change");
|
|
assertEquals( "state", listen.getPropertyName(0), "prop ev name");
|
|
assertEquals(Block.UNDETECTED, (int)listen.getOldValue(0), "old value");
|
|
assertEquals( Block.UNKNOWN, (int)listen.getNewValue(0), "new value");
|
|
|
|
assertEquals( Block.OCC_SENSOR_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertNull( listen.getOldValue(1), "old value");
|
|
assertEquals( sensorUnknownState, listen.getNewValue(1), "new value");
|
|
|
|
b.setSensor("ISunknownState");
|
|
assertEquals( 2, listen.getNumPropChanges(), "same sensor, no prop change");
|
|
|
|
b.setSensor("ISInactiveState");
|
|
assertEquals( 4, listen.getNumPropChanges(), "list size +2, state change, occ sense change");
|
|
assertEquals( "state", listen.getPropertyName(2), "prop ev name");
|
|
assertEquals( Block.UNKNOWN, (int)listen.getOldValue(2), "old value");
|
|
assertEquals( Block.UNOCCUPIED, (int)listen.getNewValue(2), "new value");
|
|
|
|
assertEquals( Block.OCC_SENSOR_CHANGE, listen.getPropertyName(3), "prop ev name");
|
|
assertEquals( sensorUnknownState, listen.getOldValue(3), "old value");
|
|
assertEquals( sensorInactiveState, listen.getNewValue(3), "new value");
|
|
|
|
b.setSensor(null);
|
|
assertEquals( 6, listen.getNumPropChanges(), "list size +2, state change, occ sense change");
|
|
assertEquals( "state", listen.getPropertyName(4), "prop ev name");
|
|
assertEquals( Block.UNOCCUPIED, (int)listen.getOldValue(4), "old value");
|
|
assertEquals( Block.UNDETECTED, (int)listen.getNewValue(4), "setSensor sets status unoccupied to undetected");
|
|
|
|
assertEquals( Block.OCC_SENSOR_CHANGE, listen.getPropertyName(5), "prop ev name");
|
|
assertEquals( sensorInactiveState, listen.getOldValue(5), "old value");
|
|
assertNull( listen.getNewValue(5), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testAddReporterPropertyChange() throws JmriException {
|
|
|
|
ReporterManager rm = InstanceManager.getDefault(ReporterManager.class);
|
|
Reporter rep = rm.provide("IR123");
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setReporter(rep);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size 1, reporter change");
|
|
assertEquals( Block.BLOCK_REPORTER_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertNull( listen.getOldValue(0), "old value");
|
|
assertEquals( rep, listen.getNewValue(0), "new value");
|
|
|
|
b.setReporter(rep);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setReporter(null);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( Block.BLOCK_REPORTER_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( rep, listen.getOldValue(1), "old value");
|
|
assertNull( listen.getNewValue(1), "new value");
|
|
}
|
|
|
|
/**
|
|
* Testing of the Reporting Current Flag being set, NOT of the Reporter mechanism.
|
|
* @throws JmriException on test error.
|
|
*/
|
|
@Test
|
|
public void testSetReportingCurrentPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
b.setReportingCurrent(false); // set initial test state
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setReportingCurrent(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size 1, property change");
|
|
assertEquals( Block.BLOCK_REPORTING_CURRENT, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Boolean.FALSE, listen.getOldValue(0), "old value");
|
|
assertEquals( Boolean.TRUE, listen.getNewValue(0), "new value");
|
|
|
|
b.setReportingCurrent(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setReportingCurrent(false);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( Block.BLOCK_REPORTING_CURRENT, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( Boolean.TRUE, listen.getOldValue(1), "old value");
|
|
assertEquals( Boolean.FALSE, listen.getNewValue(1), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetStatePropertyChangeName() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
b.setState(Block.UNDETECTED); // set initial test state
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setState(Block.UNOCCUPIED);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( "state", listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Block.UNOCCUPIED, (int)listen.getNewValue(0), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetValuePropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
b.setValue(null); // set initial test state
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setValue("String Block Value");
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( "value", listen.getPropertyName(0), "prop ev name");
|
|
assertNull( listen.getOldValue(0), "old value");
|
|
assertEquals( "String Block Value", listen.getNewValue(0), "new value");
|
|
|
|
b.setValue("String Block Value");
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setValue("New Block Value");
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( "value", listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( "String Block Value", listen.getOldValue(1), "old value");
|
|
assertEquals( "New Block Value", listen.getNewValue(1), "new value");
|
|
|
|
b.setValue(null);
|
|
assertEquals( 3, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( "value", listen.getPropertyName(2), "prop ev name");
|
|
assertEquals( "New Block Value", listen.getOldValue(2), "old value");
|
|
assertNull( listen.getNewValue(2), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetDirectionPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
b.setDirection(Path.NORTH); // set initial test state
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setDirection(Path.EAST);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( Path.EAST, b.getDirection(), "Direction set");
|
|
assertEquals( "direction", listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Path.NORTH, (int)listen.getOldValue(0), "old value");
|
|
assertEquals( Path.EAST, (int)listen.getNewValue(0), "new value");
|
|
|
|
b.setDirection(Path.EAST);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setDirection(Path.WEST);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( Path.WEST, b.getDirection(), "Direction set");
|
|
assertEquals( "direction", listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( Path.EAST, (int)listen.getOldValue(1), "old value");
|
|
assertEquals( Path.WEST, (int)listen.getNewValue(1), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetGetPermissiveWorkingPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
assertFalse( b.getPermissiveWorking(), "block not permissive to start");
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setPermissiveWorking(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertTrue( b.getPermissiveWorking(), "block permissive set");
|
|
assertEquals( Block.BLOCK_PERMISSIVE_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Boolean.FALSE, listen.getOldValue(0), "old value");
|
|
assertEquals( Boolean.TRUE, listen.getNewValue(0), "new value");
|
|
|
|
b.setPermissiveWorking(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setPermissiveWorking(false);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertFalse( b.getPermissiveWorking(), "block not permissive when set");
|
|
assertEquals( Block.BLOCK_PERMISSIVE_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( Boolean.TRUE, listen.getOldValue(1), "old value");
|
|
assertEquals( Boolean.FALSE, listen.getNewValue(1), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetIsGhostPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
assertFalse( b.getIsGhost(), "block not a ghost to start");
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setIsGhost(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertTrue( b.getIsGhost(), "block permissive set");
|
|
assertEquals( Block.GHOST_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Boolean.FALSE, listen.getOldValue(0), "old value");
|
|
assertEquals( Boolean.TRUE, listen.getNewValue(0), "new value");
|
|
|
|
b.setIsGhost(true);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setIsGhost(false);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertFalse( b.getIsGhost(), "block not permissive when set");
|
|
assertEquals( Block.GHOST_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( Boolean.TRUE, listen.getOldValue(1), "old value");
|
|
assertEquals( Boolean.FALSE, listen.getNewValue(1), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetSpeedPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
String speedA = InstanceManager.getDefault(SignalSpeedMap.class).getValidSpeedNames().firstElement();
|
|
String speedB = InstanceManager.getDefault(SignalSpeedMap.class).getValidSpeedNames().lastElement();
|
|
assertFalse( speedA.equals(speedB), "Sample speed text needs changing");
|
|
|
|
b.setBlockSpeed(speedA); // set initial test state
|
|
assertEquals( speedA, b.getBlockSpeed(), "block speedA set");
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setBlockSpeed(speedB);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( speedB, b.getBlockSpeed(), "block speedB set");
|
|
assertEquals( Block.BLOCK_SPEED_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( speedA, listen.getOldValue(0), "old value");
|
|
assertEquals( speedB, listen.getNewValue(0), "new value");
|
|
|
|
b.setBlockSpeed(speedB);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setBlockSpeed(speedA);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( speedA, b.getBlockSpeed(), "block speedA set");
|
|
assertEquals( Block.BLOCK_SPEED_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( speedB, listen.getOldValue(1), "old value");
|
|
assertEquals( speedA, listen.getNewValue(1), "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testSetCurvaturePropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
assertEquals( Block.NONE, b.getCurvature(), "no initial curvature");
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setCurvature(Block.TIGHT);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( Block.BLOCK_CURVATURE_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( Block.NONE, (int)listen.getOldValue(0), "old value");
|
|
assertEquals( Block.TIGHT, (int)listen.getNewValue(0), "new value");
|
|
|
|
b.setCurvature(Block.TIGHT);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setCurvature(Block.GRADUAL);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( Block.BLOCK_CURVATURE_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( Block.TIGHT, (int)listen.getOldValue(1), "old value");
|
|
assertEquals( Block.GRADUAL, (int)listen.getNewValue(1), "new value");
|
|
}
|
|
|
|
@Test
|
|
public void testSetGetLengthPropertyChange() throws JmriException {
|
|
|
|
Block b = new Block("BlockSystemName");
|
|
Listen listen = new Listen();
|
|
|
|
assertEquals( 0.0f, b.getLengthMm(), 0, "no initial length mm");
|
|
assertEquals( 0.0f, b.getLengthCm(), 0, "no initial length cm");
|
|
assertEquals( 0.0f, b.getLengthIn(), 0, "no initial length in");
|
|
b.addPropertyChangeListener(listen);
|
|
|
|
b.setLength(47f);
|
|
assertEquals( 1, listen.getNumPropChanges(), "1 property change");
|
|
assertEquals( 47.0f, b.getLengthMm(), 0.01, "mm set to 47");
|
|
assertEquals( 4.7f, b.getLengthCm(), 0.01, "cm set to 4.7");
|
|
assertEquals( 1.850f, b.getLengthIn(), 0.01, "Inches set to ");
|
|
assertEquals( Block.BLOCK_LENGTH_CHANGE, listen.getPropertyName(0), "prop ev name");
|
|
assertEquals( 0.0f, (float)listen.getOldValue(0),0.01, "old value");
|
|
assertEquals( 47.0f, (float)listen.getNewValue(0),0.01, "new value");
|
|
|
|
b.setLength(47f);
|
|
assertEquals( 1, listen.getNumPropChanges(), "list size still 1");
|
|
|
|
b.setLength(20f);
|
|
assertEquals( 2, listen.getNumPropChanges(), "+1 property change");
|
|
assertEquals( 20.0f, b.getLengthMm(), 0.001, "mm set to 20");
|
|
assertEquals( 2.0f, b.getLengthCm(), 0.001, "cm set to 2.0");
|
|
assertEquals( 0.787f, b.getLengthIn(), 0.001, "Inches set to ");
|
|
assertEquals( Block.BLOCK_LENGTH_CHANGE, listen.getPropertyName(1), "prop ev name");
|
|
assertEquals( 47.0f, (float)listen.getOldValue(1),0.01, "old value");
|
|
assertEquals( 20.0f, (float)listen.getNewValue(1),0.01, "new value");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testDescribeState() {
|
|
Block t = new Block("testDescribeState");
|
|
assertEquals("Unknown", t.describeState(Block.UNKNOWN));
|
|
assertEquals("Inconsistent", t.describeState(Block.INCONSISTENT));
|
|
assertEquals("Occupied", t.describeState(Block.OCCUPIED));
|
|
assertEquals("UnOccupied", t.describeState(Block.UNOCCUPIED));
|
|
assertEquals("Undetected", t.describeState(Block.UNDETECTED));
|
|
assertEquals("Unexpected value: 777", t.describeState(777));
|
|
t.dispose();
|
|
}
|
|
|
|
/**
|
|
* Class to log Property Changes.
|
|
*/
|
|
private static class Listen implements PropertyChangeListener {
|
|
|
|
List<PropertyChangeEvent> propChangeNames = Collections.synchronizedList(new ArrayList<>());
|
|
|
|
@Override
|
|
public void propertyChange(PropertyChangeEvent e) {
|
|
propChangeNames.add(e);
|
|
}
|
|
|
|
public int getNumPropChanges(){
|
|
return propChangeNames.size();
|
|
}
|
|
|
|
public String getPropertyName(int index){
|
|
return propChangeNames.get(index).getPropertyName();
|
|
}
|
|
|
|
public Object getOldValue(int index){
|
|
return propChangeNames.get(index).getOldValue();
|
|
}
|
|
|
|
public Object getNewValue(int index){
|
|
return propChangeNames.get(index).getNewValue();
|
|
}
|
|
|
|
}
|
|
|
|
@BeforeEach
|
|
public void setUp() {
|
|
JUnitUtil.setUp();
|
|
JUnitUtil.resetInstanceManager();
|
|
JUnitUtil.initInternalSensorManager();
|
|
JUnitUtil.initInternalTurnoutManager();
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
JUnitUtil.tearDown();
|
|
}
|
|
|
|
}
|