package jmri.jmrit.operations.trains; import java.io.*; import org.junit.Assert; import org.junit.jupiter.api.*; import jmri.InstanceManager; import jmri.jmrit.operations.OperationsTestCase; import jmri.jmrit.operations.locations.*; import jmri.jmrit.operations.rollingstock.cars.*; import jmri.jmrit.operations.rollingstock.engines.Engine; import jmri.jmrit.operations.rollingstock.engines.EngineManager; import jmri.jmrit.operations.routes.*; import jmri.jmrit.operations.setup.Setup; import jmri.jmrit.operations.trains.schedules.TrainScheduleManager; import jmri.util.JUnitOperationsUtil; /** * * @author Paul Bender Copyright (C) 2017 * @author Dan Boudreau Copyright (C) 2018, 2026 * * TODO data check of switch list files */ public class TrainSwitchListsTest extends OperationsTestCase { private TrainManager tmanager; private RouteManager rmanager; private LocationManager lmanager; private EngineManager emanager; private CarManager cmanager; private Location locationA; private Location locationAhyphen; @Test public void testCTor() { TrainSwitchLists t = new TrainSwitchLists(); Assert.assertNotNull("exists", t); } @Test public void testDefaults() { // the assumed defaults for this set of tests Assert.assertFalse(Setup.isBuildAggressive()); Assert.assertEquals("default moves for a route", 5, Setup.getCarMoves()); Assert.assertTrue(Setup.isSwitchListRealTime()); } @Test public void testNoSwichListFile() { loadLocationsEnginesAndCars(); File switchListFile = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertFalse(switchListFile.exists()); } @Test public void testSwitchListRealTime() throws IOException { loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); route.addLocation(locationA); locationA.setSwitchListComment("Location A switch list comment"); train.setRoute(route); train.setNumberEngines("1"); // request an engine Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); BufferedReader in = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 30, in.lines().count()); in.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } @Test public void testSwitchListTrain() throws IOException { Setup.setSwitchListPageFormat(Setup.PAGE_PER_VISIT); loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); Location locationB = lmanager.newLocation("Test Location B"); Track yardB = locationB.addTrack("Yard at B", Track.YARD); yardB.setLength(400); Location locationC = lmanager.newLocation("Test Location C"); Track yardC = locationC.addTrack("Yard at C", Track.YARD); yardC.setLength(180); // only enough room for one car and engine // create the route route.addLocation(locationA); route.addLocation(locationB); RouteLocation rlc = route.addLocation(locationC); rlc.setComment("Only one drop at location C"); train.setRoute(route); train.setNumberEngines("1"); // request an engine // place one car at location B for pick up Car c6 = cmanager.getByRoadAndNumber("AA", "6"); Assert.assertEquals("Place car on track", Track.OKAY, c6.setLocation(locationB, yardB)); Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); File switchListFileB = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationB.getName()); Assert.assertTrue(switchListFileB.exists()); File switchListFileC = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationC.getName()); Assert.assertTrue(switchListFileC.exists()); BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 27, inA.lines().count()); BufferedReader inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 20, inB.lines().count()); BufferedReader inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 18, inC.lines().count()); // this train has no work at all locations Train train2 = tmanager.newTrain("Test switchlists train 2"); train2.setRoute(route); Assert.assertTrue(train2.build()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); // no change in switch lists inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 27, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 20, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 18, inC.lines().count()); inA.close(); inB.close(); inC.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } /** * Creates a switch list for a train that visits a location twice * @throws IOException BufferedReader close */ @Test public void testSwitchListTrainTurn() throws IOException { Setup.setPrintLoadsAndEmptiesEnabled(true); // improve test coverage Setup.setSwitchListPageFormat(Setup.PAGE_PER_VISIT); Setup.setSwitchListAllTrainsEnabled(true); loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); Location locationB = lmanager.newLocation("Test Location B"); Track yardB = locationB.addTrack("Yard at B", Track.YARD); yardB.setLength(400); Location locationC = lmanager.newLocation("Test Location C"); Track yardC = locationC.addTrack("Yard at C", Track.YARD); yardC.setLength(80); // only enough room for one car Location locationD = lmanager.newLocation("Test Location D"); // create the turn route.addLocation(locationA); route.addLocation(locationB); RouteLocation rlc = route.addLocation(locationC); route.addLocation(locationD); // no tracks at D, so no work RouteLocation rld = route.addLocation(locationD); // change direction route.addLocation(locationC); route.addLocation(locationB); // no work at B at this time route.addLocation(locationA); rlc.setComment("Test comment for location C"); // confirm that the default train direction was north Assert.assertEquals("default train direction", RouteLocation.NORTH, rlc.getTrainDirection()); rld.setTrainDirection(RouteLocation.SOUTH); train.setRoute(route); train.setNumberEngines("1"); // request an engine // place one car at location B for pick up Car c6 = cmanager.getByRoadAndNumber("AA", "6"); Assert.assertEquals("Place car on track", Track.OKAY, c6.setLocation(locationB, yardB)); Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); // improve test coverage, switch list for a location without work tsl.buildSwitchList(locationD); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); File switchListFileB = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationB.getName()); Assert.assertTrue(switchListFileB.exists()); File switchListFileC = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationC.getName()); Assert.assertTrue(switchListFileC.exists()); File switchListFileD = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationD.getName()); Assert.assertTrue(switchListFileD.exists()); // note that any changes to switch list will cause the following tests to fail BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 36, inA.lines().count()); BufferedReader inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 30, inB.lines().count()); BufferedReader inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 24, inC.lines().count()); BufferedReader inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 12, inD.lines().count()); train.move(); // move train to B tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 23, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 29, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 24, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 12, inD.lines().count()); train.move(rlc); // move train to C Assert.assertEquals("current train location", "Test Location C", train.getCurrentRouteLocation().getName()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); // should report that already serviced train tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 23, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 23, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 23, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 12, inD.lines().count()); train.move(); // move train to D Assert.assertEquals("current train location", "Test Location D", train.getCurrentRouteLocation().getName()); train.move(); // move train to D reverse direction Assert.assertEquals("current train location", "Test Location D", train.getCurrentRouteLocation().getName()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 23, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 23, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 18, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 9, inD.lines().count()); train.move(); // move train to C Assert.assertEquals("current train location", "Test Location C", train.getCurrentRouteLocation().getName()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 23, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 23, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 17, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 9, inD.lines().count()); train.move(); // move train to B Assert.assertEquals("current train location", "Test Location B", train.getCurrentRouteLocation().getName()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 23, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 22, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 17, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 9, inD.lines().count()); train.move(); // move train to A Assert.assertEquals("current train location", "Test Location A", train.getCurrentRouteLocation().getName()); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 22, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 19, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 17, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 9, inD.lines().count()); train.move(); // terminate train tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); tsl.buildSwitchList(locationD); inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 9, inA.lines().count()); inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 10, inB.lines().count()); inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 7, inC.lines().count()); inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 4, inD.lines().count()); inA.close(); inB.close(); inC.close(); inD.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } /** * Creates a switch list for two trains that are turns. * @throws IOException BufferedReader close */ @Test public void testSwitchListTrainTurnPagePerTrain() throws IOException { Setup.setPrintLoadsAndEmptiesEnabled(true); // improve test coverage Setup.setSwitchListPageFormat(Setup.PAGE_PER_TRAIN); Setup.setSwitchListAllTrainsEnabled(true); loadLocationsEnginesAndCars(); Train train1 = tmanager.newTrain("Test switchlists train 1"); Train train2 = tmanager.newTrain("Test switchlists train 2"); Route route = rmanager.newRoute("Test switchlists route"); Location locationB = lmanager.newLocation("Test Location B"); Track yardB = locationB.addTrack("Yard at B", Track.YARD); yardB.setLength(400); Location locationC = lmanager.newLocation("Test Location C"); Track yardC = locationC.addTrack("Yard at C", Track.YARD); yardC.setLength(80); // only enough room for one car Location locationD = lmanager.newLocation("Test Location D"); // create the turn RouteLocation rla = route.addLocation(locationA); route.addLocation(locationB); RouteLocation rlc = route.addLocation(locationC); route.addLocation(locationD); // no tracks at D, so no work RouteLocation rld = route.addLocation(locationD); // change direction route.addLocation(locationC); route.addLocation(locationB); // no work at B at this time route.addLocation(locationA); rla.setMaxCarMoves(3); rlc.setComment("Test comment for location C"); // confirm that the default train direction was north Assert.assertEquals("default train direction", RouteLocation.NORTH, rlc.getTrainDirection()); rld.setTrainDirection(RouteLocation.SOUTH); train1.setRoute(route); train1.setNumberEngines("1"); // request an engine train2.setRoute(route); // place one car at location B for pick up Car c6 = cmanager.getByRoadAndNumber("AA", "6"); Assert.assertEquals("Place car on track", Track.OKAY, c6.setLocation(locationB, yardB)); Assert.assertTrue(train1.build()); Assert.assertTrue(train2.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); tsl.buildSwitchList(locationB); tsl.buildSwitchList(locationC); // improve test coverage, switch list for a location without work tsl.buildSwitchList(locationD); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); File switchListFileB = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationB.getName()); Assert.assertTrue(switchListFileB.exists()); File switchListFileC = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationC.getName()); Assert.assertTrue(switchListFileC.exists()); File switchListFileD = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationD.getName()); Assert.assertTrue(switchListFileD.exists()); // note that any changes to switch list will cause the following tests to fail BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 49, inA.lines().count()); BufferedReader inB = JUnitOperationsUtil.getBufferedReader(switchListFileB); Assert.assertEquals("confirm number of lines in switch list", 44, inB.lines().count()); BufferedReader inC = JUnitOperationsUtil.getBufferedReader(switchListFileC); Assert.assertEquals("confirm number of lines in switch list", 39, inC.lines().count()); BufferedReader inD = JUnitOperationsUtil.getBufferedReader(switchListFileD); Assert.assertEquals("confirm number of lines in switch list", 19, inD.lines().count()); JUnitOperationsUtil.checkOperationsShutDownTask(); } @Test public void testSwitchListTwoColumnFormat() throws IOException { Setup.setManifestFormat(Setup.TWO_COLUMN_FORMAT); Setup.setSwitchListPageFormat(Setup.PAGE_PER_TRAIN); loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); route.addLocation(locationA); train.setRoute(route); train.setNumberEngines("1"); // request an engine Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 30, inA.lines().count()); inA.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } @Test public void testSwitchListTwoColumnTrackFormat() throws IOException { Setup.setManifestFormat(Setup.TWO_COLUMN_TRACK_FORMAT); loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); route.addLocation(locationA); train.setRoute(route); train.setNumberEngines("1"); // request an engine Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 39, inA.lines().count()); inA.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } @Test public void testSwitchListNotRealTime() throws IOException { Setup.setSwitchListRealTime(false); loadLocationsEnginesAndCars(); Setup.setSwitchListPageFormat(Setup.PAGE_PER_TRAIN); // for better test coverage Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); route.addLocation(locationA); train.setRoute(route); Train train2 = tmanager.newTrain("Test switchlists train 2"); train2.setRoute(route); // use the same route TrainSwitchLists tsl = new TrainSwitchLists(); // test no new work tsl.buildSwitchList(locationA); // now create some work Assert.assertTrue(train.build()); tsl.buildSwitchList(locationA); // now append new work to file Assert.assertTrue(train2.build()); Assert.assertEquals("Confirm append mode", Location.SW_APPEND, locationA.getSwitchListState()); tsl.buildSwitchList(locationA); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 26, inA.lines().count()); inA.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } @Test public void testSwitchListSwitcher() throws IOException { loadLocationsEnginesAndCars(); Train train = tmanager.newTrain("Test switchlists train"); Route route = rmanager.newRoute("Test switchlists route"); route.addLocation(locationA); route.addLocation(locationAhyphen); // "similar" name for location A train.setRoute(route); Train train2 = tmanager.newTrain("Test switchlists train 2"); train2.setRoute(route); // use the same route train.setNumberEngines("1"); // request an engine Assert.assertTrue(train.build()); TrainSwitchLists tsl = new TrainSwitchLists(); tsl.buildSwitchList(locationA); File switchListFileA = InstanceManager.getDefault(TrainManagerXml.class).getSwitchListFile(locationA.getName()); Assert.assertTrue(switchListFileA.exists()); BufferedReader inA = JUnitOperationsUtil.getBufferedReader(switchListFileA); Assert.assertEquals("confirm number of lines in switch list", 29, inA.lines().count()); inA.close(); JUnitOperationsUtil.checkOperationsShutDownTask(); } /** * Unique data for this test. Any changes below can affect the number of * lines in the switch list file */ private void loadLocationsEnginesAndCars() { CarTypes ct = InstanceManager.getDefault(CarTypes.class); // register the car and engine types used ct.addName("Boxcar"); locationA = lmanager.newLocation("Test Location A"); Track spurA = locationA.addTrack("Spur at A", Track.SPUR); spurA.setLength(400); Track yardA = locationA.addTrack("Yard at A", Track.YARD); yardA.setLength(400); // create a "similar" location and track names with a hyphen added to it locationAhyphen = lmanager.newLocation(locationA.getName() + "-1"); Track spurAA = locationAhyphen.addTrack("Spur at A-1", Track.SPUR); spurAA.setLength(400); Track yardAA = locationAhyphen.addTrack("Yard at A-1", Track.YARD); yardAA.setLength(400); // place 6 cars JUnitOperationsUtil.createAndPlaceCar("AA", "1", "Boxcar", "40", "DAB", "1984", spurA, 0); JUnitOperationsUtil.createAndPlaceCar("AA", "2", "Boxcar", "40", "DAB", "1984", spurA, 0); JUnitOperationsUtil.createAndPlaceCar("AA", "3", "Boxcar", "40", "DAB", "1984", spurA, 0); // 3 on yard tracks JUnitOperationsUtil.createAndPlaceCar("AA", "4", "Boxcar", "40", "DAB", "1984", yardA, 0); JUnitOperationsUtil.createAndPlaceCar("AA", "5", "Boxcar", "40", "DAB", "1984", yardA, 0); Car c6 = JUnitOperationsUtil.createAndPlaceCar("AA", "6", "Boxcar", "40", "DAB", "1984", yardA, 20); c6.setUtility(true); // make this car a utility car for better test coverage Engine e1 = emanager.newRS("NYC", "1"); e1.setModel("E8"); Assert.assertEquals("Place engine on track", Track.OKAY, e1.setLocation(locationA, yardA)); } @Override @BeforeEach public void setUp() { super.setUp(); // setup new managers tmanager = InstanceManager.getDefault(TrainManager.class); rmanager = InstanceManager.getDefault(RouteManager.class); lmanager = InstanceManager.getDefault(LocationManager.class); emanager = InstanceManager.getDefault(EngineManager.class); cmanager = InstanceManager.getDefault(CarManager.class); // disable build messages tmanager.setBuildMessagesEnabled(false); // disable build reports tmanager.setBuildReportEnabled(false); Setup.setBuildAggressive(false); Setup.setStagingTrainCheckEnabled(true); Setup.setMaxTrainLength(1000); Setup.setRouterBuildReportLevel(Setup.BUILD_REPORT_VERY_DETAILED); Setup.setLocalInterchangeMovesEnabled(false); Setup.setLocalSpurMovesEnabled(false); Setup.setLocalYardMovesEnabled(false); Setup.setCarMoves(5); Setup.setMaxNumberEngines(6); Setup.setStagingTrainCheckEnabled(true); Setup.setStagingAllowReturnEnabled(false); Setup.setGenerateCsvManifestEnabled(false); Setup.setStagingPromptToEnabled(false); Setup.setCarRoutingEnabled(true); // improve test coverage Setup.setSwitchListAllTrainsEnabled(false); Setup.setPrintTrainScheduleNameEnabled(true); Setup.setSwitchListRouteLocationCommentEnabled(true); TrainScheduleManager tsmanager = InstanceManager.getDefault(TrainScheduleManager.class); tsmanager.setTrainScheduleActiveId(tsmanager.getSchedulesByIdList().get(0).getId()); } @Override @AfterEach public void tearDown() { super.tearDown(); } // private static final Logger log = LoggerFactory.getLogger(TrainSwitchListsTest.class); }