Serge NOEL
334 lines
19 KiB
Java
334 lines
19 KiB
Java
package jmri.jmrit.dispatcher;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.StandardCopyOption;
|
|
|
|
import jmri.*;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
import org.junit.jupiter.api.io.TempDir;
|
|
|
|
import org.netbeans.jemmy.operators.JFrameOperator;
|
|
|
|
import jmri.configurexml.JmriConfigureXmlException;
|
|
import jmri.implementation.SignalSpeedMap;
|
|
import jmri.jmrit.logix.WarrantPreferences;
|
|
import jmri.util.FileUtil;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
|
|
/**
|
|
*
|
|
* @author Steve Gigiel 2018
|
|
*
|
|
* Tests the LoadAtStartUp function for Dispatcher In addition it tests auto
|
|
* running of a train.
|
|
*/
|
|
@jmri.util.junit.annotations.DisabledIfHeadless
|
|
public class LoadAtStartUpTest {
|
|
|
|
// Only one aat at a time
|
|
private AutoActiveTrain aat = null;
|
|
private static final double TOLERANCE = 0.0001;
|
|
|
|
private static void increaseWaitForStep() {
|
|
JUnitUtil.WAITFOR_DELAY_STEP = 20;
|
|
}
|
|
|
|
@Test
|
|
public void testShowAndClose() throws JmriConfigureXmlException, JmriException {
|
|
// Assume.assumeFalse("Ignoring intermittent test", Boolean.getBoolean("jmri.skipTestsRequiringSeparateRunning"));
|
|
jmri.configurexml.ConfigXmlManager cm = new jmri.configurexml.ConfigXmlManager() {
|
|
};
|
|
// more time for us less for the waitfor code...
|
|
LoadAtStartUpTest.increaseWaitForStep();
|
|
WarrantPreferences.getDefault().setShutdown(WarrantPreferences.Shutdown.NO_MERGE);
|
|
|
|
// load layout file
|
|
java.io.File f = new java.io.File("java/test/jmri/jmrit/dispatcher/DispatcherSMLLayout.xml");
|
|
Assertions.assertTrue(cm.load(f));
|
|
|
|
InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager.class).initializeLayoutBlockPaths();
|
|
|
|
// load dispatcher, with all the correct options
|
|
OptionsFile.setDefaultFileName("java/test/jmri/jmrit/dispatcher/TestTrainDispatcherOptions.xml");
|
|
DispatcherFrame d = InstanceManager.getDefault(DispatcherFrame.class);
|
|
JFrameOperator dw = new JFrameOperator(Bundle.getMessage("TitleDispatcher"));
|
|
|
|
// signal mast managerls -l
|
|
SignalMastManager smm = InstanceManager.getDefault(SignalMastManager.class);
|
|
|
|
checkAndSetSpeeds();
|
|
|
|
BlockManager bm = InstanceManager.getDefault(BlockManager.class);
|
|
for (Block b : bm.getNamedBeanSet()) {
|
|
b.setState(Block.UNOCCUPIED);
|
|
}
|
|
// place train on layout
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Platform"),Block.OCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Platform Switch"),Block.OCCUPIED); // set blocker
|
|
|
|
// and load. only one of 2 trains will load
|
|
d.loadAtStartup();
|
|
assertThat(d.getActiveTrainsList().size()).withFailMessage("Train Loaded").isEqualTo(1);
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Platform Switch"),Block.UNOCCUPIED); // release blocker
|
|
|
|
// trains loads and runs, 4 allocated sections, the one we are in and 3 ahead.
|
|
JUnitUtil.waitFor(() -> {
|
|
return d.getAllocatedSectionsList().size() == 4;
|
|
}, "Allocate Sections ahead");
|
|
assertThat(d.getAllocatedSectionsList()).withFailMessage("Allocated sections 4").hasSize(4);
|
|
// get autoactivetrain object
|
|
ActiveTrain at = d.getActiveTrainsList().get(0);
|
|
aat = at.getAutoActiveTrain();
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Clear".equals(smm.provideSignalMast("West End Div").getAspect());
|
|
}, "Signal West End Div now green");
|
|
// check signals and speed
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("1 West End Div Signal Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("1 West To South Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("1 South To East Signal Green").isEqualTo("Approach");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("1 East End Throat Signal Green").isEqualTo("Stop");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "Exit South Platform Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Platform Switch"),Block.OCCUPIED);
|
|
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Stop".equals(smm.provideSignalMast("West End Div").getAspect());
|
|
}, "Signal Just passed stop");
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("2 West End Div Signal Stop").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("2 West To South Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("2 South To East Signal Green").isEqualTo("Approach");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("2 East End Throat Signal Green").isEqualTo("Stop");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "West Platform Switch Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Block"),Block.OCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Platform"),Block.UNOCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Platform Switch"),Block.UNOCCUPIED);
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Clear".equals(smm.provideSignalMast("South To East").getAspect());
|
|
}, "Signal South To East now Clear");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("3 West To South Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("3 South To East Signal Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("3 East End Throat Signal Approach").isEqualTo("Approach");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "South To East Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Block"),Block.OCCUPIED);
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Stop".equals(smm.provideSignalMast("West To South").getAspect());
|
|
}, "Signal Just passed West To South now stop");
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("4 West End Div Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("4 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("4 South To East Signal Green").isEqualTo("Clear");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("4 East End Throat Signal Green").isEqualTo("Approach");
|
|
String strSigSpeed = (String) smm.provideSignalMast("South To East").getSignalSystem().getProperty(smm.provideSignalMast("South To East").getAspect(), "speed");
|
|
assertThat(InstanceManager.getDefault(SignalSpeedMap.class).getSpeed(strSigSpeed)/100).isEqualTo(speedNormal);
|
|
//The signal head indicates 1.0f but train is limited to a max of 0.6f
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - 0.6f ) < TOLERANCE ); }, "West To South Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("West Block"),Block.UNOCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Block"),Block.OCCUPIED);
|
|
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Stop".equals(smm.provideSignalMast("South To East").getAspect());
|
|
}, "Signal Just passed south to east now stop");
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("5 West End Div Signal Green").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("5 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("5 South To East Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("5 East End Throat Signal yellow").isEqualTo("Approach");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "South To East Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Block"),Block.UNOCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Platform Switch"),Block.OCCUPIED);
|
|
JUnitUtil.waitFor(() -> {
|
|
return "Stop".equals(smm.provideSignalMast("East End Throat").getAspect());
|
|
}, "Signal Just passed east end throat now stop");
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("6 West End Div Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("6 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("6 South To East Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("6 East End Throat Signal Red").isEqualTo("Stop");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "East Platform Switch Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Platform Switch"),Block.OCCUPIED);
|
|
// No change
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("7 West End Div Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("7 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("7 South To East Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("7 East End Throat Signal Red").isEqualTo("Stop");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE ); }, "East Platform Switch Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Platform"),Block.OCCUPIED);
|
|
// signals no change, speed changes
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("8 West End Div Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("8 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("8 South To East Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("8 East End Throat Signal Red").isEqualTo("Stop");
|
|
JUnitUtil.waitFor(() -> { return (Math.abs(aat.getTargetSpeed() - speedRestrictedSlow ) < TOLERANCE ); }, "Speed is correct");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Block"),Block.UNOCCUPIED);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Platform Switch"),Block.UNOCCUPIED);
|
|
// signals no change, speed changes to stop
|
|
assertThat(smm.provideSignalMast("West End Div").getAspect()).withFailMessage("9 West End Div Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("West To South").getAspect()).withFailMessage("9 West To South Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("South To East").getAspect()).withFailMessage("9 South To East Signal Red").isEqualTo("Stop");
|
|
assertThat(smm.provideSignalMast("East End Throat").getAspect()).withFailMessage("9 East End Throat Signal Red").isEqualTo("Stop");
|
|
|
|
// train slows to stop
|
|
JUnitUtil.waitFor(() -> {
|
|
return (Math.abs(aat.getTargetSpeed() ) < TOLERANCE );
|
|
}, "Signal Just passed east end throat now stop");
|
|
|
|
JUnitUtil.waitFor(2200);
|
|
// check for next train note dcc name is original transit name has changed
|
|
assertEquals( "1000 / SouthPlatFormReturnToSouthCC",
|
|
d.getActiveTrainsList().get(0).getActiveTrainName(), "Next Train Load");
|
|
JUnitUtil.waitFor(2000);
|
|
// its a new train.
|
|
at = d.getActiveTrainsList().get(0);
|
|
aat = at.getAutoActiveTrain();
|
|
JUnitUtil.waitFor(() -> {
|
|
return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE );
|
|
}, "Started to move");
|
|
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Platform Switch"),Block.OCCUPIED);
|
|
JUnitUtil.waitFor(50);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Block"),Block.OCCUPIED);
|
|
JUnitUtil.waitFor(50);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Platform"),Block.UNOCCUPIED);
|
|
|
|
JUnitUtil.waitFor(() -> {
|
|
return (Math.abs(aat.getTargetSpeed() - speedRestricted ) < TOLERANCE );
|
|
}, "Continuing speed was "+ aat.getTargetSpeed() + " not " + speedRestricted);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("South Block"),Block.OCCUPIED);
|
|
|
|
JUnitUtil.waitFor(() -> {
|
|
return (Math.abs(aat.getTargetSpeed() - speedRestrictedSlow ) < TOLERANCE );
|
|
}, "Prepare to stop");
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Platform Switch"),Block.UNOCCUPIED);
|
|
JUnitUtil.waitFor(50);
|
|
JUnitUtil.setBeanStateAndWait(bm.provideBlock("East Block"),Block.UNOCCUPIED);
|
|
// train slows to stop
|
|
JUnitUtil.waitFor(() -> {
|
|
return (Math.abs(aat.getTargetSpeed() ) < TOLERANCE );
|
|
}, "Did not Stop " + at.getActiveTrainName() + " with throttle SpeedSetting " + aat.getTargetSpeed());
|
|
//terminates at end
|
|
// wait for cleanup to finish
|
|
JUnitUtil.waitFor(200);
|
|
|
|
assertThat((d.getActiveTrainsList().isEmpty())).withFailMessage("All trains terminated").isTrue();
|
|
|
|
JFrameOperator aw = new JFrameOperator("AutoTrains");
|
|
|
|
aw.requestClose();
|
|
aw.waitClosed();
|
|
dw.requestClose();
|
|
dw.waitClosed();
|
|
|
|
JFrameOperator le = new JFrameOperator("Test Layout");
|
|
JUnitUtil.dispose(le.getWindow());
|
|
le.waitClosed();
|
|
|
|
// cleanup window
|
|
JUnitUtil.dispose(d);
|
|
InstanceManager.getDefault(jmri.SignalMastManager.class).dispose();
|
|
InstanceManager.getDefault(jmri.SignalMastLogicManager.class).dispose();
|
|
}
|
|
|
|
private float speedStopping = 0.0f;
|
|
private float speedSlow = 0.0f;
|
|
private float speedRestrictedSlow = 0.0f;
|
|
private float speedRestricted = 0.0f;
|
|
private float speedMedium = 0.0f;
|
|
private float speedNormal = 0.0f;
|
|
|
|
private void checkAndSetSpeeds() {
|
|
// Check we have got the right signal map
|
|
speedStopping = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed(InstanceManager.getDefault(DispatcherFrame.class).getStoppingSpeedName())/100.0f;
|
|
assertEquals(0.1f, speedStopping, TOLERANCE );
|
|
speedNormal = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed("Normal")/100.0f;
|
|
assertEquals(1.0f, speedNormal, TOLERANCE );
|
|
speedMedium = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed("Medium")/100.0f;
|
|
assertEquals(0.5f, speedMedium, TOLERANCE );
|
|
speedSlow = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed("Slow")/100.0f;
|
|
assertEquals(0.31f, speedSlow, TOLERANCE );
|
|
speedRestricted = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed("Restricted")/100.0f;
|
|
assertEquals(0.35f, speedRestricted, TOLERANCE );
|
|
speedRestrictedSlow = InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getSpeed("RestrictedSlow")/100.0f;
|
|
assertEquals(0.1f, speedRestrictedSlow, TOLERANCE);
|
|
assertEquals(SignalSpeedMap.PERCENT_THROTTLE, InstanceManager.getDefault(SignalSpeedMap.class)
|
|
.getInterpretation(), TOLERANCE);
|
|
}
|
|
|
|
// Where in user space the "signals" file tree should live
|
|
private File outBaseTrainInfo = null;
|
|
private File outBaseSignal = null;
|
|
|
|
// the file we create that we will delete
|
|
private Path outPathTrainInfo1 = null;
|
|
private Path outPathTrainInfo2 = null;
|
|
private Path outPathTrainInfo3 = null;
|
|
private Path outPathWarrentPreferences = null;
|
|
|
|
|
|
@BeforeEach
|
|
public void setUp(@TempDir File tempDir) throws IOException {
|
|
JUnitUtil.setUp();
|
|
JUnitUtil.resetProfileManager( new jmri.profile.NullProfile( tempDir));
|
|
|
|
JUnitUtil.initRosterConfigManager();
|
|
JUnitUtil.initDebugThrottleManager();
|
|
|
|
// set up users files in temp tst area
|
|
outBaseTrainInfo = new File(FileUtil.getUserFilesPath(), "dispatcher/traininfo");
|
|
outBaseSignal = new File(FileUtil.getUserFilesPath(), "signal");
|
|
|
|
FileUtil.createDirectory(outBaseTrainInfo);
|
|
{
|
|
Path inPath = new File(new File(FileUtil.getProgramPath(), "java/test/jmri/jmrit/dispatcher/traininfo"),
|
|
"TestTrainCW.xml").toPath();
|
|
outPathTrainInfo1 = new File(outBaseTrainInfo, "TestTrainCW.xml").toPath();
|
|
Files.copy(inPath, outPathTrainInfo1, StandardCopyOption.REPLACE_EXISTING);
|
|
}
|
|
{
|
|
Path inPath = new File(new File(FileUtil.getProgramPath(), "java/test/jmri/jmrit/dispatcher/traininfo"),
|
|
"TestTrainCW_Return.xml").toPath();
|
|
outPathTrainInfo3 = new File(outBaseTrainInfo, "TestTrainCW_Return.xml").toPath();
|
|
Files.copy(inPath, outPathTrainInfo3, StandardCopyOption.REPLACE_EXISTING);
|
|
}
|
|
{
|
|
Path inPath = new File(new File(FileUtil.getProgramPath(), "java/test/jmri/jmrit/dispatcher/traininfo"),
|
|
"TestTrain.xml").toPath();
|
|
outPathTrainInfo2 = new File(outBaseTrainInfo, "TestTrain.xml").toPath();
|
|
Files.copy(inPath, outPathTrainInfo2, StandardCopyOption.REPLACE_EXISTING);
|
|
}
|
|
FileUtil.createDirectory(outBaseSignal);
|
|
{
|
|
Path inPath = new File(new File(FileUtil.getProgramPath(), "java/test/jmri/jmrit/dispatcher/signal"),
|
|
"WarrantPreferences.xml").toPath();
|
|
outPathWarrentPreferences = new File(outBaseSignal, "WarrantPreferences.xml").toPath();
|
|
Files.copy(inPath, outPathWarrentPreferences, StandardCopyOption.REPLACE_EXISTING);
|
|
}
|
|
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
|
|
JUnitUtil.resetInstanceManager();
|
|
JUnitUtil.clearShutDownManager();
|
|
JUnitUtil.tearDown();
|
|
}
|
|
}
|