18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 05:16:01 +01:00

Merge remote-tracking branch 'origin/master' into feat/elf-master-controller-emergency-brake

# Conflicts:
#	McZapkie/Mover.cpp
This commit is contained in:
jerrrrycho
2026-11-09 15:30:38 +01:00
155 changed files with 8068 additions and 546 deletions

View File

@@ -0,0 +1,46 @@
{
"_comment": "Diesel-electric locomotive made after the SU46 (303D): the line contactors close on the first power position of the master controller, the pressure switch (on by default) opens them with too low a pressure in the main pipe or the brakes applied.",
"Param": { "Category": "train", "M": 105000, "Mred": 15000, "Vmax": 120, "PWR": 1400, "SandCap": 400 },
"Dimensions": { "L": 18.99, "H": 4.292, "W": 2.904, "Cx": 0.3 },
"Wheels": { "D": 1.1, "AIM": 4000, "Tw": 1.435, "Axle": "Co'Co'", "Ad": 1.75, "Bd": 10.3, "Rmin": 100 },
"Brake": {
"BrakeValve": "LSt", "NBpA": 4, "MBF": 85.0, "MaxBP": 4.4, "LocMaxBP": 4.4, "MaxASBP": 1.3, "RM": 0.71, "BCN": 12, "BCR": 0.114,
"BCD": 0.06, "BCM": 5.84, "HiPP": 5, "LoPP": 3.5, "Vv": 0.9, "MinCP": 7, "MaxCP": 8.5, "CompressorSpeed": 0.05, "BCS": 1, "BSA": 2,
"BM": "P10-Bgu", "CompressorPower": "Converter", "BVV": 200, "BRE": 0.8
},
"BuffCoupl": { "CType": "Screw", "kB": 9200, "DmaxB": 0.15, "FmaxB": 740, "kC": 4800, "DmaxC": 0.15, "FmaxC": 780, "beta": 0.58, "AllowedFlag": 103 },
"Cntrl": {
"BrakeHandle": "FV4a", "LocBrakeHandle": "FD1", "BrakeSystem": "Pneumatic", "BDelay1": 15, "BDelay2": 6, "BDelay3": 36, "BDelay4": 32,
"ASB": "Manual", "LocalBrake": "PneumaticBrake", "MCPN": 15, "SCPN": 4, "AutoRelay": "Yes", "IniCDelay": 0.5, "SCDelay": 0.1,
"BrakeDelays": "GPR", "ConverterStart": "Automatic", "ConverterStartDelay": 10
},
"Light": { "Light": "Generator", "LGeneratorEngine": "ElectricSeriesMotor", "LMaxVoltage": 110, "LMaxCurrent": 100 },
"Engine": {
"AIM": 1.6, "EngineType": "DumbDE", "Trans": "18:62", "Ftmax": 317000, "Flat": 0, "Vhyp": 15.0, "Vadd": 3.8, "Cr": 1.0, "RelayType": 46,
"OilMinPressure": 0.055, "OilMaxPressure": 0.6, "WaterMinTemperature": 40, "WaterMaxTemperature": 92, "WaterCoolingTemperature": 76,
"HeatKW": 0.068599, "HeatKV": 0.3, "HeatKFE": 1, "HeatKFS": 87.76269, "HeatKFO": 26.72716, "HeatKFO2": 57.72
},
"Circuit": { "CircuitRes": 0.01, "ImaxLo": 3300, "IminLo": 2500 },
"_power": "rows: engine speed [rpm], power [kW], generator voltage limit, current limit, one per master controller position",
"WWList": {
"Size": 15,
"rows": [
[696, 0, 0, 0],
[696, 0, 0, 0],
[696, 80, 350, 1000],
[696, 80, 350, 1000],
[763, 214, 455, 1400],
[830, 321, 500, 1600],
[897, 428, 545, 1800],
[964, 535, 590, 2000],
[1031, 642, 635, 2200],
[1098, 748, 680, 2400],
[1165, 855, 725, 2600],
[1232, 962, 770, 2800],
[1299, 1069, 815, 3000],
[1366, 1176, 865, 3200],
[1433, 1283, 910, 3400],
[1500, 1390, 960, 3600]
]
}
}

View File

@@ -0,0 +1,53 @@
{
"_comment": "Diesel shunter with a mechanical gearbox, made after the SM03 (Ls150): the fuel pump starts on its own with the engine, a converter run by the engine feeds the low voltage circuit, the only cab control of the engine is the starter button.",
"Param": { "Category": "train", "M": 23200, "Vmax": 25.68, "PWR": 111.855, "SandCap": 200 },
"Dimensions": { "L": 6.94, "H": 3.21, "W": 2.97, "Cx": 0.3 },
"Wheels": { "D": 0.94, "Tw": 1.435, "AIM": 250, "Axle": "B", "Ad": 2.5, "Bd": 2.5, "Rmin": 50, "BearingType": "Roll" },
"Brake": {
"BrakeValve": "K", "NBpA": 2, "MBF": 85.0, "MaxBP": 3.5, "LocMaxBP": 5.0, "BCN": 1, "BCR": 0.114, "BCD": 0.12, "BCM": 10.0,
"HiPP": 5, "LoPP": 3.5, "Vv": 0.3, "MinCP": 7.0, "MaxCP": 8.0, "CompressorSpeed": 0.0125, "CompressorPower": "Main",
"BCS": 0.8, "BSA": 0, "BM": "P10-Bg", "BVV": 40, "BRE": 0.9
},
"BuffCoupl": { "CType": "Screw", "kB": 9200, "DmaxB": 0.15, "FmaxB": 740, "kC": 4800, "DmaxC": 0.15, "FmaxC": 780, "beta": 0.58, "AllowedFlag": 3 },
"Cntrl": {
"BrakeSystem": "Pneumatic", "BDelay1": 15, "BDelay2": 4, "ASB": "Manual", "LocalBrake": "PneumaticBrake", "ManualBrake": "Yes",
"DynamicBrake": "Passive", "MCPN": 9, "SCPN": 7, "AutoRelay": "No", "IniCDelay": 0.5, "SCDelay": 0.1, "BrakeDelays": "P",
"BrakeHandle": "Knorr", "LocBrakeHandle": "Knorr", "FuelStart": "Automatic", "ConverterStart": "Automatic"
},
"Light": { "Light": "Generator", "LGeneratorEngine": "ElectricSeriesMotor", "LMaxVoltage": 24, "LMaxCurrent": 100 },
"Engine": {
"EngineType": "DieselEngine", "Trans": "1:1", "nmin": 900, "nmax": 1500, "nmax_cutoff": 1550, "AIM": 100,
"OilMinPressure": 0.343, "OilMaxPressure": 0.686, "WaterCoolingTemperature": 80, "WaterShutters": "yes", "WaterAuxCircuit": "no",
"HeatKFO": 160, "HeatKFO2": 180, "HeatKFS": 160, "HeatKFE": 7, "HeatKW": 2, "HeatKV": 0.3, "IsTC": "No", "EUS": 0.35, "EDS": 1.0
},
"_gears": "rows: gear, ratio, engagement speed, top speed; the even ones neutral",
"MotorParamTable": {
"minVelfullengage": 3.8, "engageDia": 1, "engageMaxForce": 800, "engagefriction": 1,
"rows": [
[0, 0, 0, -1],
[1, 46.88, -1, 5.73],
[2, 0, 0, -1],
[3, 28.65, 2.9, 9.42],
[4, 0, 0, -1],
[5, 17.12, 4.7, 15.69],
[6, 0, 0, -1],
[7, 10.46, 10.6, 100]
]
},
"_throttle": "rows: position, fill, speed governor mode; position 0 idles",
"DList": {
"Size": 9, "Mmax": 784.5, "nMmax": 15, "Mnmax": 686.4, "nmax": 25, "nominalfill": 1, "Mstand": 200.0,
"rows": [
[0, 0.1, 0],
[1, 0.2, 2],
[2, 0.3, 2],
[3, 0.4, 2],
[4, 0.5, 2],
[5, 0.6, 2],
[6, 0.7, 2],
[7, 0.8, 2],
[8, 0.9, 2],
[9, 1.0, 2]
]
}
}

View File

@@ -5,6 +5,21 @@
namespace test {
namespace {
// whether the pressure switch of a vehicle in the train still cuts the start off: a half of a locomotive whose
// switch is on when the controller leaves zero doesn't close its line contactors until the controller is back at zero
bool start_cut_off(consist &Train) {
for (std::size_t i = 0; i < Train.size(); ++i) {
if (Train[i].mover().ControlPressureSwitch) {
return true;
}
}
return false;
}
} // namespace
scenario::scenario(std::string Name, std::vector<channel> Channels, track const &Track) : m_name(std::move(Name)), m_channels(std::move(Channels)), m_track(Track) {
reseed_random();
}
@@ -53,6 +68,11 @@ void scenario::get_going() {
void scenario::full_power(double Seconds) {
auto &controlling{driver().controlling};
// as a driver does, wait for the brakes to let go far enough for every pressure switch of the train to allow the
// start; otherwise whether all the halves of a locomotive start hangs on thousandths of a bar of their cylinders
for (int i = 0; i < 120 && start_cut_off(m_train); ++i) {
wait(1.0);
}
controlling.IncMainCtrl(1);
for (int i = 0; i < 90 && false == controlling.StLinFlag; ++i) {
wait(1.0);

View File

@@ -0,0 +1,31 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
using test::definition;
using test::vehicle;
// the hints for the AI driver from the AI section of the .fiz
TEST_CASE("ai hints: without the AI section the pantographs follow the built-in logic") {
vehicle wagon{definition::load("wagon")};
CHECK(wagon->AIHintPantstate == 0);
CHECK(wagon->AIHintShuntPantstate == 0);
CHECK(wagon->AIHintPantUpIfIdle);
}
TEST_CASE("ai hints: the suggested pantograph setup for shunting is read apart from the one for train mode") {
// eu07/maszyna#461: so the ET41 doesn't shunt with all of its four pantographs up
vehicle shunting{definition::load("wagon").set("AI", "Pantstate", 1).set("AI", "ShuntPantstate", 2)};
CHECK(shunting->AIHintPantstate == 1);
CHECK(shunting->AIHintShuntPantstate == 2);
}
TEST_CASE("ai hints: a .fiz with the setup for train mode only has none for shunting") {
vehicle train{definition::load("wagon").set("AI", "Pantstate", 3)};
CHECK(train->AIHintPantstate == 3);
CHECK(train->AIHintShuntPantstate == 0);
}

View File

@@ -4,6 +4,7 @@
#include "golden.h"
#include "real_vehicles.h"
#include "drive.h"
#include "consist.h"
#include "McZapkie/hamulce.h"
@@ -35,6 +36,7 @@ void hold(vehicle &Vehicle, test::trace &Trace, std::string const &Event, double
// every position of the driver's handle, recorded in the trace
void every_position(vehicle &Vehicle, test::trace &Trace) {
Vehicle.hold_main_reservoir(std::max(Vehicle->MaxCompressor, 8.0));
REQUIRE(Vehicle->Handle != nullptr);
auto &handle{*Vehicle->Handle};
Vehicle.record(Trace);
@@ -57,6 +59,13 @@ void every_position(vehicle &Vehicle, test::trace &Trace) {
hold(Vehicle, Trace, "running", handle.GetPos(bh_RP), 60.0);
}
// the handle put to the given position and the vehicle driven from its cab for Seconds, marked in the trace
void driven_at(vehicle &Vehicle, test::trace &Trace, std::string const &Event, double Position, double Seconds) {
Trace.mark(Event);
Vehicle->BrakeLevelSet(Position);
test::drive(test::driving(Vehicle), {}, Seconds);
}
} // namespace
TEST_CASE("brake handles: every position of the driver's handle of every real vehicle") {
@@ -96,6 +105,7 @@ TEST_CASE("brake handles: the local brake handle of every real vehicle") {
real.hold_main_reservoir(std::max(real->MaxCompressor, 8.0));
test::trace trace{"local brake/" + path, handle_channels(), 100};
real.record(trace);
REQUIRE(real->Handle != nullptr);
real->BrakeLevelSet(real->Handle->GetPos(bh_RP));
trace.mark("charge");
real.run(60.0);
@@ -126,25 +136,21 @@ TEST_CASE("brake handles: the overload and the high pressure buttons of the MHZ
real.hold_main_reservoir(std::max(real->MaxCompressor, 8.0));
test::trace trace{"brake handles/buttons/" + name, handle_channels(), 100};
real.record(trace);
REQUIRE(real->Handle != nullptr);
auto &handle{*real->Handle};
auto const at{[&trace, &real](std::string const &Event, double Position, double Seconds) {
trace.mark(Event);
real->BrakeLevelSet(Position);
test::drive(test::driving(real), {}, Seconds);
}};
at("running", handle.GetPos(bh_RP), 60.0);
driven_at(real, trace, "running", handle.GetPos(bh_RP), 60.0);
auto const running{real->PipePress};
handle.SetUniversalFlag(TUniversalBrake::ub_Overload);
at("overload button", handle.GetPos(bh_RP), 30.0);
driven_at(real, trace, "overload button", handle.GetPos(bh_RP), 30.0);
handle.SetUniversalFlag(0);
auto const overloaded{real->PipePress};
at("overload decaying", handle.GetPos(bh_RP), 240.0);
driven_at(real, trace, "overload decaying", handle.GetPos(bh_RP), 240.0);
auto const decayed{real->PipePress};
handle.SetUniversalFlag(TUniversalBrake::ub_HighPressure);
at("high pressure button, filling stroke", handle.GetPos(bh_FS), 10.0);
driven_at(real, trace, "high pressure button, filling stroke", handle.GetPos(bh_FS), 10.0);
auto const filled{real->PipePress};
handle.SetUniversalFlag(0);
at("running", handle.GetPos(bh_RP), 120.0);
driven_at(real, trace, "running", handle.GetPos(bh_RP), 120.0);
CHECK(running == doctest::Approx(5.0).epsilon(0.01));
CHECK(overloaded > running + 0.3);
CHECK(decayed < overloaded);
@@ -152,3 +158,110 @@ TEST_CASE("brake handles: the overload and the high pressure buttons of the MHZ
trace.check();
}
}
// eu07/maszyna#134: the Knorr St113 of the EN57-001 releases the EP brake in the running position (bh_RP, Num 6)
// and applies it one position on (Num 8), short of the lap position (Num 5); the positions are those the keys
// select, and the EP brake works only with the control of the cab powered: the battery, the reverser out of
// neutral and the EP fuse on (Ctrl+Z), as the Oerlikon handle's
namespace {
// the front car of the EN57-001 driven from its cab, with the motor car behind it, which has the battery of the two;
// air in the reservoirs, the battery on
void ready_knorr_ep(test::consist &Unit) {
Unit.add(definition::fiz("en57_v1/6bai"), 1);
Unit.add(definition::fiz("en57_v1/5bgb"));
auto &cab{Unit[0]};
REQUIRE(cab->BrakeHandle == TBrakeHandle::St113);
REQUIRE(cab->Handle != nullptr);
cab->BatterySwitch(true);
cab->CabActivisation();
cab.hold_brake_pipe(5.0);
cab->BrakeLevelSet(cab->Handle->GetPos(bh_RP));
Unit.run(60.0);
}
// the EP brake button pressed in the given handle position, held for Seconds; the cylinder pressure of the cab car
double ep_brake(test::consist &Unit, double Position, double Seconds) {
auto &cab{Unit[0]};
cab->BrakeLevelSet(Position);
Unit.run(0.1);
cab->SwitchEPBrake(1);
Unit.run(Seconds);
return cab->BrakePress;
}
// the EP force the St113 handle of the cab car gives in the given position
double ep_at(test::consist &Unit, double Position) {
auto &cab{Unit[0]};
cab->BrakeLevelSet(Position);
Unit.run(0.1);
return cab->Handle->GetEP();
}
} // namespace
TEST_CASE("brake handles: the positions of the Knorr St113 EP brake") {
test::consist unit;
ready_knorr_ep(unit);
auto &cab{unit[0]};
REQUIRE(cab->Handle != nullptr);
auto &handle{*cab->Handle};
// the keys: Num 6 running, Num 8 the first position on, Num 5 the middle of the handle
CHECK(handle.GetPos(bh_RP) == doctest::Approx(0.0));
CHECK(ep_at(unit, 0.0) == doctest::Approx(-1.0)); // EP release
CHECK(ep_at(unit, 1.0) == doctest::Approx(1.0)); // EP brake
CHECK(ep_at(unit, cab->BrakeCtrlPosNo / 2) == doctest::Approx(0.0)); // lap, Num 5
CHECK(ep_at(unit, handle.GetPos(bh_FB)) == doctest::Approx(0.0));
CHECK(ep_at(unit, handle.GetPos(bh_EPR)) == doctest::Approx(-1.0));
CHECK(ep_at(unit, handle.GetPos(bh_EPB)) == doctest::Approx(1.0));
}
TEST_CASE("brake handles: the Knorr St113 EP brake needs the control of the cab powered") {
for (std::string const cut : {"reverser in neutral", "EP fuse off", "battery off"}) {
CAPTURE(cut);
test::consist unit;
ready_knorr_ep(unit);
auto &cab{unit[0]};
cab->DirectionForward();
unit.run(1.0);
REQUIRE(cab->EPBrakeControlPowered());
if (cut == "reverser in neutral") {
cab->DirectionBackward();
}
else if (cut == "EP fuse off") {
cab->EpFuseSwitch(false);
}
else {
cab->BatterySwitch(false);
}
unit.run(1.0);
REQUIRE_FALSE(cab->EPBrakeControlPowered());
// the button in the EP brake position does nothing
CHECK(ep_brake(unit, 1.0, 5.0) < 0.1);
CHECK(cab->EpForce == doctest::Approx(0.0));
cab->SwitchEPBrake(0);
}
test::consist unit;
ready_knorr_ep(unit);
auto &cab{unit[0]};
cab->DirectionForward();
unit.run(1.0);
// powered, the EP brake applies
auto const applied{ep_brake(unit, 1.0, 2.0)};
CHECK(applied > 0.5);
// the reverser put to neutral with the button still held: the EP brake drops out and holds what it applied
cab->DirectionBackward();
unit.run(0.1);
CHECK(cab->EpForce == doctest::Approx(0.0));
auto const held{cab->BrakePress};
unit.run(5.0);
CHECK(cab->BrakePress < held + 0.05);
CHECK(cab->BrakePress > 0.2);
// and doesn't release either, until the control is powered again
CHECK(ep_brake(unit, 0.0, 5.0) > 0.2);
cab->SwitchEPBrake(0);
cab->DirectionForward();
unit.run(0.1);
CHECK(ep_brake(unit, 0.0, 10.0) < 0.1);
}

View File

@@ -1,6 +1,7 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
#include "consist.h"
using test::definition;
using test::vehicle;
@@ -91,3 +92,48 @@ TEST_CASE("brakes: service braking stops a heavier wagon too") {
wagon.run(40.0 /* s */, test::track{0.15 /* friction */, 0.0 /* gradient */});
CHECK(std::abs(wagon.speed()) < 0.1);
}
// eu07/maszyna#87: the ESt4d of the EN57's EP2 valve charged its auxiliary reservoir from the main reservoir pipe
// alone, so a dead unit hauled by a locomotive coupled with the hook and the brake hose ("3") never charged it,
// its control reservoir stopped half way, and it didn't brake. Like every ESt, it charges from the brake pipe too
TEST_CASE("brakes: a dead EN57 hauled with the brake hose alone charges from the brake pipe and brakes") {
test::consist train;
auto &locomotive{train.add(definition::fiz("sm42_v1/6d1"))};
train.add(definition::fiz("en57_v1/5bgb"), 0, coupling::coupler | coupling::brakehose);
train.add(definition::fiz("en57_v1/6ba_840"));
train.add(definition::fiz("en57_v1/5bgaiii_led_spot"));
// a unit standing dead: no air anywhere, nothing in its main reservoir pipe
for (std::size_t i = 1; i < train.size(); ++i) {
auto &car{train[i].mover()};
REQUIRE(car.BrakeValve == TBrakeValve::EP2);
car.Hamulec->ForceEmptiness();
car.Pipe->CreatePress(0.0);
car.Pipe->Act();
car.Pipe2->CreatePress(0.0);
car.Pipe2->Act();
car.CompressedVolume = 0.0;
}
locomotive.hold_brake_pipe(5.0);
train.run(900.0);
for (std::size_t i = 1; i < train.size(); ++i) {
CAPTURE(i);
auto &car{train[i].mover()};
REQUIRE(car.ScndPipePress < 0.1); // no main reservoir pipe
CHECK(car.Hamulec->GetBRP() > 4.8);
CHECK(car.Hamulec->GetCRP() > 4.8);
CHECK(car.BrakePress < 0.1);
}
// a full service application brakes the unit, and it releases again
locomotive.hold_brake_pipe(3.5);
train.run(20.0);
for (std::size_t i = 1; i < train.size(); ++i) {
CAPTURE(i);
CHECK(train[i]->BrakePress > 2.0);
}
locomotive.hold_brake_pipe(5.0);
train.run(60.0);
for (std::size_t i = 1; i < train.size(); ++i) {
CAPTURE(i);
CHECK(train[i]->BrakePress < 0.1);
}
}

View File

@@ -227,3 +227,204 @@ TEST_CASE("cab: the lamps and the buzzer of the security system left unattended"
CHECK(security.radiostop_available());
scenario.check();
}
namespace {
// the SM42, its shunt mode switching its vigilance device (CA) off or not (AwareOffInShuntMode), set in the
// test whatever the converted definition says
definition sm42_vigilance(bool const Off) {
return definition::fiz("sm42_v1/6d1").set("Security", "AwareOffInShuntMode", Off ? "Yes" : "No");
}
// runs the train for Seconds with nobody acknowledging the vigilance; returns whether the vigilance alarm came
bool unattended(scenario &Scenario, int const Seconds) {
bool blinked{false};
for (int i = 0; i < Seconds; ++i) {
Scenario.train().run(1.0, Scenario.line());
blinked |= Scenario.cab().SecuritySystem.is_vigilance_blinking();
}
return blinked;
}
} // namespace
TEST_CASE("cab: the SM42's vigilance device switched off in the shunt mode, where its definition says so") {
// eu07/maszyna#457: with AwareOffInShuntMode=Yes the shunt mode of the SM42 switches its vigilance device (CA)
// off, it alerts again once the shunt mode is off
scenario scenario{"cab/sm42 vigilance in shunt mode", motion() + brakes(), test::track{}};
scenario.train().add(sm42_vigilance(true), 1);
REQUIRE(scenario.start_up());
auto &sm42{scenario.cab()};
auto const &security{sm42.SecuritySystem};
REQUIRE(sm42.CurrentSwitch(true));
REQUIRE(sm42.ShuntMode);
scenario.get_going();
sm42.AnPos = 0.3;
sm42.IncMainCtrl(1);
scenario.act("unattended in shunt mode");
bool blinked{false};
for (int i = 0; i < 120; ++i) {
scenario.train().run(1.0, scenario.line());
blinked |= security.is_blinking();
}
CHECK(sm42.Vel > 1.0);
CHECK_FALSE(blinked);
CHECK(sm42.PipePress > 3.5);
scenario.act("shunt mode off");
scenario.notch_back(0);
REQUIRE(sm42.CurrentSwitch(false));
sm42.IncMainCtrl(1);
scenario.act("unattended");
CHECK(unattended(scenario, 120));
scenario.check();
}
TEST_CASE("cab: the vigilance device of the SM42 kept in the shunt mode, by default") {
// without AwareOffInShuntMode the shunt mode leaves the vigilance device alone: unattended, it alerts and brakes
scenario scenario{"cab/sm42 vigilance kept in shunt mode", motion() + brakes(), test::track{}};
scenario.train().add(sm42_vigilance(false), 1);
REQUIRE(scenario.start_up());
auto &sm42{scenario.cab()};
REQUIRE(sm42.CurrentSwitch(true));
REQUIRE(sm42.ShuntMode);
scenario.get_going();
sm42.AnPos = 0.3;
sm42.IncMainCtrl(1);
scenario.act("unattended in shunt mode");
CHECK(unattended(scenario, 120));
CHECK(sm42.ShuntMode);
CHECK(sm42.PipePress < 1.0);
scenario.check();
}
TEST_CASE("cab: the SM42's vigilance alarm on, not cleared by switching into the shunt mode") {
// the shunt mode switches the vigilance device off for the time to come: an alarm already on goes on to the
// emergency braking, until the driver acknowledges it (#275 review)
scenario scenario{"cab/sm42 vigilance alarm into shunt mode", motion() + brakes(), test::track{}};
scenario.train().add(sm42_vigilance(true), 1);
REQUIRE(scenario.start_up());
auto &sm42{scenario.cab()};
auto const &security{sm42.SecuritySystem};
scenario.get_going();
sm42.IncMainCtrl(1);
scenario.act("unattended");
// the alerter counts only on the move, which takes a while on the first notch
for (int i = 0; i < 300 && false == security.is_vigilance_blinking(); ++i) {
scenario.train().run(1.0, scenario.line());
}
REQUIRE(security.is_vigilance_blinking());
REQUIRE_FALSE(security.is_braking());
scenario.act("shunt mode on");
for (int i = 0; i < 20 && false == sm42.IsMainCtrlNoPowerPos(); ++i) {
sm42.DecMainCtrl(1);
}
REQUIRE(sm42.CurrentSwitch(true));
REQUIRE(sm42.ShuntMode);
scenario.train().run(15.0, scenario.line());
CHECK(security.is_vigilance_blinking());
CHECK(security.is_beeping());
CHECK(security.is_braking());
CHECK(sm42.PipePress < 1.0);
scenario.act("acknowledged");
sm42.SecuritySystemReset();
scenario.train().run(1.0, scenario.line());
CHECK_FALSE(security.is_blinking());
CHECK_FALSE(security.is_braking());
scenario.check();
}
namespace {
TSecuritySystem sm42_security(bool const OffInShuntMode) {
TSecuritySystem security;
security.load(std::string{"Security: AwareSystem=Active AwareMinSpeed=0.0 AwareDelay=60 SoundSignalDelay=2.5 MaxHoldTime=1.0 "
"EmergencyBrakeDelay=2.5 AwareOffInShuntMode="} +
(OffInShuntMode ? "Yes" : "No"),
90.0);
security.set_enabled(true);
security.update(0.1, 20.0, true, 1);
return security;
}
void run(TSecuritySystem &Security, double const Seconds) {
for (int i = 0; i < std::lround(Seconds / 0.1); ++i) {
Security.update(0.1, 20.0, true, 1);
}
}
} // namespace
TEST_CASE("cab: the alerter in the shunt mode, with and without AwareOffInShuntMode") {
for (auto const off : {false, true}) {
CAPTURE(off);
auto security{sm42_security(off)};
security.set_shunt_mode(true);
run(security, 120.0);
// without the key the shunt mode changes nothing: the alerter alerts and brakes
CHECK(security.is_vigilance_blinking() != off);
CHECK(security.is_braking() != off);
}
}
TEST_CASE("cab: the alerter's alarm on, not cleared by the shunt mode") {
auto security{sm42_security(true)};
run(security, 61.0);
REQUIRE(security.is_vigilance_blinking());
REQUIRE_FALSE(security.is_braking());
security.set_shunt_mode(true);
run(security, 10.0);
CHECK(security.is_vigilance_blinking());
CHECK(security.is_beeping());
CHECK(security.is_braking());
security.acknowledge_press();
security.acknowledge_release();
run(security, 0.1);
CHECK_FALSE(security.is_blinking());
CHECK_FALSE(security.is_braking());
// then nothing more on the move in the shunt mode
run(security, 300.0);
CHECK_FALSE(security.is_blinking());
// and back in the line mode the alerter counts again
security.set_shunt_mode(false);
run(security, 61.0);
CHECK(security.is_vigilance_blinking());
}
TEST_CASE("cab: the vigilance button held too long, its alarm not cleared by the shunt mode") {
// the alarm of the button held too long stays on in the shunt mode too, until the button is let go
TSecuritySystem security;
security.load("Security: AwareSystem=Active AwareMinSpeed=0.0 AwareDelay=60 SoundSignalDelay=2.5 MaxHoldTime=1.0 "
"EmergencyBrakeDelay=2.5 AwareOffInShuntMode=Yes",
90.0);
security.set_enabled(true);
security.update(0.1, 20.0, true, 1);
security.acknowledge_press();
for (int i = 0; i < 20; ++i) {
security.update(0.1, 20.0, true, 1);
}
REQUIRE(security.is_vigilance_blinking());
security.set_shunt_mode(true);
for (int i = 0; i < 60; ++i) {
security.update(0.1, 20.0, true, 1);
}
CHECK(security.is_vigilance_blinking());
CHECK(security.is_braking());
security.acknowledge_release();
security.update(0.1, 20.0, true, 1);
CHECK_FALSE(security.is_blinking());
CHECK_FALSE(security.is_braking());
// held again in the shunt mode, no new alarm
security.acknowledge_press();
for (int i = 0; i < 100; ++i) {
security.update(0.1, 20.0, true, 1);
}
CHECK_FALSE(security.is_blinking());
security.acknowledge_release();
// out of the shunt mode, held too long again
security.set_shunt_mode(false);
security.acknowledge_press();
for (int i = 0; i < 20; ++i) {
security.update(0.1, 20.0, true, 1);
}
CHECK(security.is_vigilance_blinking());
}

View File

@@ -37,3 +37,145 @@ TEST_CASE("cntrl: the relays of a multiple unit start on their own, of other veh
CHECK(unit->ConverterOverloadRelayStart == start_t::automatic);
}
}
namespace {
// the first position of the master controller after Position without the starting resistors in the circuit
int resistance_free_position(TMoverParameters const &Vehicle, int Position = 0) {
for (auto position{Position + 1}; position <= Vehicle.MainCtrlPosNo; ++position) {
if (Vehicle.RList[position].R < 0.01) {
return position;
}
}
return 0;
}
// the vehicle with its cab occupied, the master controller set to Position and the shunt controller off
void controllers_at(vehicle &Vehicle, int Position) {
Vehicle->CabActive = 1;
Vehicle->MainCtrlPos = Position;
Vehicle->ScndCtrlPos = 0;
}
} // namespace
TEST_CASE("cntrl: ScndCtrlResistiveLock keeps the field shunting off at zero and on the resistive positions (eu07/maszyna#402)") {
for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) {
CAPTURE(path);
vehicle locked{definition::fiz(path).set("Cntrl", "ScndCtrlResistiveLock", "Yes"), 0.0, "test", 1};
REQUIRE(locked->ScndCtrlResistiveLock);
REQUIRE(locked->ScndCtrlPosNo > 0);
auto const resistancefree{resistance_free_position(locked.mover())};
REQUIRE(resistancefree > 1);
if (resistancefree <= 1) {
continue; // not reached, the REQUIRE above ends the test; tells the static analysis the index below is in range
}
REQUIRE(locked->RList[resistancefree - 1].R >= 0.01);
SUBCASE("zero") {
controllers_at(locked, 0);
CHECK(locked->IsScndCtrlLockedByMainCtrl());
CHECK_FALSE(locked->IncScndCtrl(1));
CHECK_FALSE(locked->IncScndCtrl(2));
CHECK(locked->ScndCtrlPos == 0);
}
SUBCASE("resistive positions") {
for (auto position{1}; position < resistancefree; ++position) {
CAPTURE(position);
controllers_at(locked, position);
CHECK_FALSE(locked->IncScndCtrl(1));
CHECK(locked->ScndCtrlPos == 0);
}
}
SUBCASE("every resistance-free position") {
for (auto position{resistancefree}; position > 0; position = resistance_free_position(locked.mover(), position)) {
CAPTURE(position);
controllers_at(locked, position);
CHECK_FALSE(locked->IsScndCtrlLockedByMainCtrl());
CHECK(locked->IncScndCtrl(1));
CHECK(locked->ScndCtrlPos == 1);
}
}
SUBCASE("the shunt goes down on a resistance-free position") {
controllers_at(locked, resistancefree);
REQUIRE(locked->IncScndCtrl(1));
REQUIRE(locked->IncScndCtrl(1));
CHECK(locked->DecScndCtrl(1));
CHECK(locked->ScndCtrlPos == 1);
CHECK(locked->DecScndCtrl(2));
CHECK(locked->ScndCtrlPos == 0);
}
SUBCASE("the shunt doesn't go down on a resistive position either") {
// a state the lock doesn't let arise (see below), set by hand to check the controller alone
controllers_at(locked, resistancefree - 1);
locked->ScndCtrlPos = 1;
CHECK(locked->IsScndCtrlLockedByMainCtrl());
CHECK_FALSE(locked->DecScndCtrl(1));
CHECK_FALSE(locked->DecScndCtrl(2));
CHECK(locked->ScndCtrlPos == 1);
}
SUBCASE("the master controller taken back from a shunt step drops the shunt") {
controllers_at(locked, resistancefree);
REQUIRE(locked->IncScndCtrl(1));
if (locked->TrainType == dt_ET22) {
// the ET22's master controller doesn't turn with the shunt on: the shunt goes off first, as before
CHECK_FALSE(locked->DecMainCtrl(1));
CHECK(locked->MainCtrlPos == resistancefree);
CHECK(locked->DecScndCtrl(1));
}
CHECK(locked->DecMainCtrl(1));
CHECK(locked->MainCtrlPos == resistancefree - 1);
CHECK(locked->ScndCtrlPos == 0);
// and the master controller goes on down to zero, nothing left locked
while (locked->MainCtrlPos > 0 && locked->DecMainCtrl(1)) {
}
CHECK(locked->MainCtrlPos == 0);
}
SUBCASE("the master controller set directly (AI, consist) drops the shunt in the next update") {
controllers_at(locked, resistancefree);
REQUIRE(locked->IncScndCtrl(1));
locked->MainCtrlPos = resistancefree - 1;
locked.step();
CHECK(locked->ScndCtrlPos == 0);
CHECK(locked->MainCtrlPos == resistancefree - 1);
}
SUBCASE("the master controller moved up from a shunt step onto a resistive position drops the shunt") {
// the last series position, followed by the resistive parallel ones
auto lastseries{0};
for (auto position{resistancefree}; position > 0 && position < locked->MainCtrlPosNo; position = resistance_free_position(locked.mover(), position)) {
if (locked->RList[position + 1].R >= 0.01) {
lastseries = position;
break;
}
}
REQUIRE(lastseries > 0);
controllers_at(locked, lastseries);
locked->DirActive = 1;
REQUIRE(locked->IncScndCtrl(1));
if (locked->TrainType == dt_ET22) {
CHECK_FALSE(locked->IncMainCtrl(1)); // the ET22's interlock, as before
CHECK(locked->ScndCtrlPos == 1);
}
else {
CHECK(locked->IncMainCtrl(1));
CHECK(locked->MainCtrlPos == lastseries + 1);
CHECK(locked->ScndCtrlPos == 0);
}
}
}
}
TEST_CASE("cntrl: without ScndCtrlResistiveLock the field shunting engages on any position, as before") {
for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) {
CAPTURE(path);
vehicle unlocked{definition::fiz(path), 0.0, "test", 1};
CHECK_FALSE(unlocked->ScndCtrlResistiveLock);
for (auto const position : {0, 1}) {
CAPTURE(position);
controllers_at(unlocked, position);
CHECK_FALSE(unlocked->IsScndCtrlLockedByMainCtrl());
CHECK(unlocked->IncScndCtrl(1));
CHECK(unlocked->ScndCtrlPos == 1);
}
}
}

View File

@@ -113,3 +113,93 @@ TEST_CASE("compressor: without a pressure switch the air over the cut-out pressu
REQUIRE(vehicle->CompressorFlag); // nothing stops it
CHECK(vehicle->CompressedVolume < 8.5 * 0.81); // a fifth of the air let out
}
TEST_CASE("compressor: an engine stopped before the delay passed counts the whole delay again") {
auto vehicle{compressor_vehicle(30.0)};
vehicle->Mains = true; // engine started
run_compressor(vehicle, 20.0);
REQUIRE_FALSE(vehicle->CompressorFlag);
vehicle->Mains = false; // engine stopped, 10 s short of the delay
run_compressor(vehicle, 1.0);
vehicle->Mains = true;
run_compressor(vehicle, 15.0); // 36 s since the first start, but only 15 s since this one
CHECK_FALSE(vehicle->CompressorFlag);
run_compressor(vehicle, 15.1);
CHECK(vehicle->CompressorFlag);
}
TEST_CASE("compressor: the start delay holds back a compressor switched on by hand too") {
auto vehicle{compressor_vehicle(30.0)};
vehicle->CompressorStart = start_t::manual;
vehicle->CompressorAllow = true; // switch in the cabinet on before the engine start
vehicle->Mains = true;
run_compressor(vehicle, 29.9);
CHECK_FALSE(vehicle->CompressorFlag);
run_compressor(vehicle, 0.2);
CHECK(vehicle->CompressorFlag);
}
TEST_CASE("compressor: the start delay is read from the brake section") {
auto const delay{[](std::string const &Section) {
return vehicle{definition::load("wagon").set(Section, "CompressorStartDelay", 30)}->CompressorStartDelay;
}};
CHECK(delay("Brake") == doctest::Approx(30.0));
CHECK(delay("Cntrl") == doctest::Approx(0.0)); // the key isn't taken from the control section
}
namespace {
// 401Da: the compressor runs from the 110 V of the auxiliary generator driven by the engine, here the converter
// started with the main circuit, which gets up to voltage the converter start delay after the engine start
definition generator_vehicle(double const ConverterDelay, double const CompressorDelay) {
return definition::load("cab_vehicle")
.set("Param", "PWR", 370)
.set("Light", "Light", "Generator")
.set("Light", "LMaxVoltage", 110)
.set("Brake", "Vv", 0.6)
.set("Brake", "MinCP", 6.5)
.set("Brake", "MaxCP", 8.0)
.set("Brake", "CompressorSpeed", 0.003)
.set("Brake", "CompressorPower", "Converter")
.set("Brake", "CompressorStartDelay", CompressorDelay)
.set("Cntrl", "CompressorStart", "Automatic")
.set("Cntrl", "ConverterStart", "Automatic")
.set("Cntrl", "ConverterStartDelay", ConverterDelay);
}
} // namespace
TEST_CASE("compressor: fed from the converter it waits for the converter start delay") {
vehicle loco{generator_vehicle(30.0, 0.0)};
REQUIRE(loco->CompressorPower == 2);
REQUIRE(loco->ConverterStartDelay == doctest::Approx(30.0));
loco.run(1.0); // engine off
CHECK_FALSE(loco->Power110vIsAvailable);
loco->Mains = true; // engine started
loco.run(25.0);
CHECK_FALSE(loco->Power110vIsAvailable);
CHECK_FALSE(loco->CompressorFlag);
loco.run(10.0);
CHECK(loco->Power110vIsAvailable);
CHECK(loco->CompressorFlag);
}
TEST_CASE("compressor: fed from the converter the start delay counts from the converter voltage") {
vehicle loco{generator_vehicle(20.0, 10.0)};
REQUIRE(loco->CompressorStartDelay == doctest::Approx(10.0));
loco.run(1.0); // engine off
loco->Mains = true; // engine started
loco.run(25.0);
REQUIRE(loco->Power110vIsAvailable); // the converter is up
CHECK_FALSE(loco->CompressorFlag); // but the compressor waits for its own delay as well
loco.run(10.0);
CHECK(loco->CompressorFlag);
}

View File

@@ -525,3 +525,130 @@ TEST_CASE("couplers: a collision of coupled vehicles keeps the momentum of the p
CHECK(0.5 * (front_wagon.speed() + rear_wagon.speed()) > 13.5);
CHECK(0.5 * (front_wagon.speed() + rear_wagon.speed()) < 15.05 + 1e-6);
}
// eu07/maszyna#520: an electric and a diesel locomotive got their control coupled (multiple-unit control) when the
// scenario or the Starter asked for it, or when the couplers let it through, as a Vectron and an SM42 did
namespace {
// the given setting of the control coupling check for the test, restored after it
class control_coupling_check_setting {
public:
explicit control_coupling_check_setting(bool Enabled) { Global.control_coupling_engine_check = Enabled; }
~control_coupling_check_setting() { Global.control_coupling_engine_check = m_previous; }
control_coupling_check_setting(control_coupling_check_setting const &) = delete;
control_coupling_check_setting &operator=(control_coupling_check_setting const &) = delete;
private:
bool m_previous{Global.control_coupling_engine_check};
};
constexpr int scenario_coupling{coupling::coupler | coupling::brakehose | coupling::mainhose | coupling::control};
// couples the rear of the first vehicle to the front of the second one the way the scenery does (forced, from the
// first one only), returns the coupling the pair got
int scenario_couple(vehicle &First, vehicle &Second, int Coupling = scenario_coupling) {
REQUIRE(First->Attach(end::rear, end::front, &Second.mover(), Coupling, true, false));
CHECK(Second->Couplers[end::front].CouplingFlag == First->Couplers[end::rear].CouplingFlag);
return First->Couplers[end::rear].CouplingFlag;
}
} // namespace
TEST_CASE("couplers: an electric and a diesel locomotive don't share their control") {
control_coupling_check_setting const check{true};
// the E6ACT names no control system (ControlType), as the Vectron doesn't; the SM42 names its own, the SM03 none
auto electric{vehicle{definition::fiz("e6act_v2/e6acta"), 0.0, "electric"}};
REQUIRE(electric->EngineType == TEngineType::ElectricInductionMotor);
SUBCASE("a diesel-electric one with its own control system") {
auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}};
REQUIRE(diesel->EngineType == TEngineType::DieselElectric);
CHECK_FALSE(electric->ControlCouplingAllowed(end::rear, diesel.mover(), end::front));
CHECK(scenario_couple(electric, diesel) == (scenario_coupling & ~coupling::control));
}
SUBCASE("a diesel-mechanical one without a control system named, either") {
auto diesel{vehicle{definition::fiz("sm03_v1/sm03"), 0.0, "diesel"}};
REQUIRE(diesel->EngineType == TEngineType::DieselEngine);
CHECK_FALSE(diesel->ControlCouplingAllowed(end::front, electric.mover(), end::rear));
CHECK(scenario_couple(diesel, electric) == (scenario_coupling & ~coupling::control));
}
SUBCASE("unless both name the same control system") {
auto diesel{vehicle{definition::fiz("sm03_v1/sm03").set("BuffCoupl", "ControlType", "shared"), 0.0, "diesel"}};
auto shared{vehicle{definition::fiz("e6act_v2/e6acta").set("BuffCoupl", "ControlType", "shared"), 0.0, "electric"}};
CHECK(scenario_couple(shared, diesel) == scenario_coupling);
}
SUBCASE("unless the vehicles make one unit, coupled for good") {
auto diesel{vehicle{definition::fiz("sm03_v1/sm03"), 0.0, "diesel"}};
auto const forgood{scenario_coupling | coupling::permanent};
CHECK(scenario_couple(electric, diesel, forgood) == forgood);
}
SUBCASE("unless the check is turned off") {
control_coupling_check_setting const off{false};
auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}};
CHECK(electric->ControlCouplingAllowed(end::rear, diesel.mover(), end::front));
CHECK(scenario_couple(electric, diesel) == scenario_coupling);
}
}
TEST_CASE("couplers: locomotives of the same traction and the cars keep their control coupling") {
control_coupling_check_setting const check{true};
SUBCASE("two locomotives or motor cars of the same traction") {
// two electric ones, an electric one of each motor type, two diesel ones, a diesel-mechanical and a
// diesel-electric one, an electric multiple unit's control trailer and its motor car
std::initializer_list<std::pair<char const *, char const *>> const pairs{
{"ep09_v2/104e", "et22_v3/201e-w"},
{"e6act_v2/e6acta", "eu04_v1/eu04-01"},
{"sm03_v1/sm03", "wmb10_v1/wmb10"},
{"sm03_v1/sm03", "st44_v2/m62-1151"},
{"en57_v1/5bgb", "en57_v1/6bai"}};
for (auto const &paths : pairs) {
CAPTURE(paths.first);
CAPTURE(paths.second);
auto first{vehicle{definition::fiz(paths.first), 0.0, "first"}};
auto second{vehicle{definition::fiz(paths.second), 0.0, "second"}};
CHECK(scenario_couple(first, second) == scenario_coupling);
}
}
SUBCASE("a diesel locomotive and a car") {
auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}};
auto car{vehicle{definition::load("wagon"), 0.0, "car"}};
CHECK(scenario_couple(diesel, car) == scenario_coupling);
}
}
TEST_CASE("couplers: automatic couplers of an electric and a diesel locomotive couple without the control connection") {
crash_damage_setting const crashdamage{true};
control_coupling_check_setting const check{true};
auto const flag{coupling::coupler | coupling::brakehose | coupling::control};
auto automatic = [flag](std::string const &Path) {
return definition::fiz(Path).set("BuffCoupl", "CType", "Automatic").set("BuffCoupl", "AutomaticFlag", flag);
};
auto moving{vehicle{automatic("e6act_v2/e6acta"), 5.0, "moving"}};
SUBCASE("a diesel one") {
auto standing{vehicle{automatic("sm03_v1/sm03"), 0.0, "standing"}};
test::pair pair{moving, end::front, standing, end::rear, 1.0};
REQUIRE(couple_during(pair, 3.0));
CHECK(pair.coupling() == (coupling::coupler | coupling::brakehose));
}
SUBCASE("an electric one") {
auto standing{vehicle{automatic("ep09_v2/104e"), 0.0, "standing"}};
test::pair pair{moving, end::front, standing, end::rear, 1.0};
REQUIRE(couple_during(pair, 3.0));
CHECK(pair.coupling() == flag);
}
}
TEST_CASE("couplers: the AI and the player get the coupling the vehicles can take") {
control_coupling_check_setting const check{true};
auto electric{vehicle{definition::fiz("e6act_v2/e6acta"), 0.0, "electric"}};
auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}};
auto other{vehicle{definition::fiz("ep09_v2/104e"), 0.0, "other"}};
CHECK(electric->CompatibleCoupling(end::rear, diesel.mover(), end::front, scenario_coupling) == (scenario_coupling & ~coupling::control));
CHECK(electric->CompatibleCoupling(end::rear, other.mover(), end::front, scenario_coupling) == scenario_coupling);
// nothing to take away without the control connection asked for
CHECK(electric->CompatibleCoupling(end::rear, diesel.mover(), end::front, coupling::coupler) == coupling::coupler);
}

View File

@@ -177,3 +177,32 @@ TEST_CASE("diesel: the 214M railbus's speed control, up to the speed of a button
CHECK_FALSE(railbus.SpeedCtrlUnit.IsActive);
scenario.check();
}
TEST_CASE("diesel: the SM42's shunt mode, switched on and off with one move of the switch") {
// eu07/maszyna#497: the shunt mode of the diesel-electrics (ShuntMode=1) shares its switch with the motor
// overload relay threshold of the electric locomotives (CurrentSwitch()). the SM42 has no such relay, so
// the switch sets the shunt mode at the first move, at the controller's zero position only
scenario scenario{"diesel/sm42 shunt mode", motion() + traction(), test::track{}};
scenario.add("sm42_v1/6d1", 1);
REQUIRE(scenario.start_up());
auto &sm42{scenario.cab()};
REQUIRE(sm42.ShuntModeAllow);
CHECK_FALSE(sm42.ShuntMode);
scenario.act("shunt mode on");
CHECK(sm42.CurrentSwitch(true));
CHECK(sm42.ShuntMode);
scenario.get_going();
scenario.act("shunting power");
sm42.AnPos = 0.5;
CHECK(sm42.IncMainCtrl(1));
scenario.wait(60.0);
CHECK(sm42.Vel > 1.0);
// not with the controller out of its zero position
CHECK_FALSE(sm42.CurrentSwitch(false));
CHECK(sm42.ShuntMode);
scenario.notch_back(0);
scenario.act("shunt mode off");
CHECK(sm42.CurrentSwitch(false));
CHECK_FALSE(sm42.ShuntMode);
scenario.check();
}

112
tests/unit/test_dimmer.cpp Normal file
View File

@@ -0,0 +1,112 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
using test::definition;
using test::vehicle;
// the headlight dimmer's position indexes the DimmerList of the .fiz. a short or an empty list, or a DefaultPos
// past its end, put the dimmer outside the list, where the lights and the cab read past the end of it
namespace {
// rows: high beam, dimmed, off
nlohmann::ordered_json const plain{"no", "no", "no"};
nlohmann::ordered_json const dimmed{"no", "yes", "no"};
nlohmann::ordered_json const off{"no", "no", "yes"};
definition dimmer_list(nlohmann::ordered_json const &Rows, int const Defaultposition, bool const Cycle = false) {
return definition::load("cab_vehicle")
.set("DimmerList", "rows", Rows)
.set("DimmerList", "Size", static_cast<int>(Rows.size()))
.set("DimmerList", "DefaultPos", Defaultposition)
.set("DimmerList", "Cycle", Cycle ? "yes" : "no");
}
} // namespace
TEST_CASE("dimmer: a position outside the list reads as a plain one, neither off nor dimmed") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({off, dimmed}), 0)};
REQUIRE(cab->dimPositions.size() == 2);
for (auto const position : {-1, 2, 100}) {
CAPTURE(position);
cab->modernDimmerPosition = position;
auto const entry{cab->currentDimPosition()};
CHECK_FALSE(entry.isOff);
CHECK_FALSE(entry.isDimmed);
CHECK_FALSE(entry.isHighBeam);
}
cab->modernDimmerPosition = 0;
CHECK(cab->currentDimPosition().isOff);
cab->modernDimmerPosition = 1;
CHECK(cab->currentDimPosition().isDimmed);
}
TEST_CASE("dimmer: positions are clamped to the list") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)};
CHECK(cab->clampDimmerPosition(-3) == 0);
CHECK(cab->clampDimmerPosition(1) == 1);
CHECK(cab->clampDimmerPosition(3) == 2);
CHECK(cab->clampDimmerPosition(100) == 2);
}
TEST_CASE("dimmer: a DefaultPos past the end of the list starts the dimmer at its last position") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed}), 7)};
CHECK(cab->modernDimmerDefaultPosition == 1);
// the cab puts the modern dimmer to its default position when it's entered (TTrain::set_cab_controls())
cab->modernDimmerPosition = cab->modernDimmerDefaultPosition;
CHECK(cab->currentDimPosition().isDimmed);
}
TEST_CASE("dimmer: without the modern dimmer a DefaultPos past the end of the list puts the dimmer at its last position") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed}), 7).set("Switches", "ModernDimmer", "No")};
REQUIRE_FALSE(cab->enableModernDimmer);
CHECK(cab->modernDimmerPosition == 1);
CHECK(cab->currentDimPosition().isDimmed);
}
TEST_CASE("dimmer: an empty list leaves the dimmer at 0, reading as a plain position, and it doesn't move") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array(), 3, true)};
REQUIRE(cab->dimPositions.empty());
CHECK(cab->modernDimmerDefaultPosition == 0);
CHECK(cab->modernDimmerPosition == 0);
CHECK(cab->clampDimmerPosition(1) == 0);
CHECK_FALSE(cab->currentDimPosition().isOff);
CHECK_FALSE(cab->stepDimmerPosition(1));
CHECK_FALSE(cab->stepDimmerPosition(-1));
CHECK(cab->modernDimmerPosition == 0);
}
TEST_CASE("dimmer: stepping stays within the list") {
SUBCASE("without cycling it stops at the ends") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)};
CHECK_FALSE(cab->stepDimmerPosition(-1));
CHECK(cab->modernDimmerPosition == 0);
CHECK(cab->stepDimmerPosition(1));
CHECK(cab->stepDimmerPosition(1));
CHECK(cab->modernDimmerPosition == 2);
CHECK_FALSE(cab->stepDimmerPosition(1));
CHECK(cab->modernDimmerPosition == 2);
}
SUBCASE("with cycling it goes around to the other end") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0, true)};
CHECK(cab->stepDimmerPosition(-1));
CHECK(cab->modernDimmerPosition == 2);
CHECK(cab->stepDimmerPosition(1));
CHECK(cab->modernDimmerPosition == 0);
}
SUBCASE("a position past the end steps from the last one") {
vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)};
cab->modernDimmerPosition = 9;
CHECK(cab->stepDimmerPosition(-1));
CHECK(cab->modernDimmerPosition == 1);
cab->modernDimmerPosition = 9;
CHECK(cab->stepDimmerPosition(1)); // can't go further, but comes back into the list
CHECK(cab->modernDimmerPosition == 2);
}
}

View File

@@ -0,0 +1,158 @@
#include "stdafx.h"
#include "doctest.h"
#include "scenario.h"
#include "vehicle.h"
// the door closure signalling (SOD, the i-door_blocked lamp of a cab): the state of each vehicle's doors and of the
// whole train, the most severe of its vehicles, as the driver gathers it for the lamp (eu07/maszyna#288)
using test::scenario;
using test::definition;
using test::vehicle;
using namespace test::channels;
namespace {
// the state of the whole train, the way TController::determine_consist_state() gathers it
door_closure_t consist_closure(scenario &Scenario) {
auto closure{door_closure_t::none};
for (std::size_t i = 0; i < Scenario.train().size(); ++i) {
closure = std::max(closure, Scenario.vehicle(i).door_closure());
}
return closure;
}
} // namespace
TEST_CASE("door closure: the lamp is lit for locked doors, blinks for released ones and is dark for open ones") {
for (auto const lit : {true, false}) {
CAPTURE(lit);
CHECK(door_closure_lamp(door_closure_t::locked, lit));
CHECK(door_closure_lamp(door_closure_t::released, lit) == lit);
CHECK_FALSE(door_closure_lamp(door_closure_t::open, lit));
CHECK_FALSE(door_closure_lamp(door_closure_t::none, lit));
}
// a consist takes the most severe state of its vehicles
CHECK(std::max(door_closure_t::none, door_closure_t::locked) == door_closure_t::locked);
CHECK(std::max(door_closure_t::locked, door_closure_t::released) == door_closure_t::released);
CHECK(std::max(door_closure_t::released, door_closure_t::open) == door_closure_t::open);
}
TEST_CASE("door closure: a unit with permits, locked, released by the permit and open, in any of its cars") {
scenario scenario{"door closure/elf", motion() + doors()};
scenario.add("elf_v1/21we-a", 1).add("elf_v1/21we-b").add("elf_v1/21we-c");
scenario.start_up();
auto &cab{scenario.cab()};
auto &last{scenario.vehicle(scenario.train().size() - 1)};
// closed with no permit: no door can be opened
CHECK(cab.door_closure() == door_closure_t::locked);
CHECK(last.door_closure() == door_closure_t::locked);
CHECK(consist_closure(scenario) == door_closure_t::locked);
scenario.act("permit left");
cab.PermitDoors(side::left, true);
scenario.wait(2.0);
CHECK(last.door_closure() == door_closure_t::released);
CHECK(consist_closure(scenario) == door_closure_t::released);
scenario.act("the last car opens its own door");
last.OperateDoors(side::left, true, range_t::local);
scenario.wait(5.0);
// the cab's own doors stay closed, the train is open all the same
CHECK(cab.door_closure() == door_closure_t::released);
CHECK(last.door_closure() == door_closure_t::open);
CHECK(consist_closure(scenario) == door_closure_t::open);
scenario.act("close, the steps stay out under the permit");
last.OperateDoors(side::left, false, range_t::local);
cab.OperateDoors(side::left, false);
scenario.wait(10.0);
CHECK(last.Doors.instances[side::left].position <= 0.f);
// a step out isn't a closed door
CHECK(consist_closure(scenario) == door_closure_t::open);
scenario.act("revoke the permit");
cab.PermitDoors(side::left, false);
scenario.wait(10.0);
CHECK(consist_closure(scenario) == door_closure_t::locked);
}
TEST_CASE("door closure: the doors of a unit without permits are released at a standstill") {
scenario scenario{"door closure/en57", motion() + doors()};
scenario.add("en57_v1/5bgaiii_led_spot", 1).add("en57_v1/6ba_840").add("en57_v1/5bgb");
scenario.start_up();
auto &cab{scenario.cab()};
auto &middle{scenario.vehicle(1)};
REQUIRE_FALSE(cab.Doors.permit_needed);
REQUIRE(middle.Doors.permit_needed);
// the door lock engages only once the train runs (DoorLockSpeed), till then the end cars' doors can be opened
CHECK(cab.door_closure() == door_closure_t::released);
CHECK(middle.door_closure() == door_closure_t::locked);
CHECK(consist_closure(scenario) == door_closure_t::released);
scenario.act("open right");
cab.OperateDoors(side::right, true);
scenario.wait(10.0);
CHECK(consist_closure(scenario) == door_closure_t::open);
scenario.act("close right");
cab.OperateDoors(side::right, false);
scenario.wait(10.0);
CHECK(consist_closure(scenario) == door_closure_t::released);
}
TEST_CASE("door closure: a locomotive has no doors to signal, its coach does") {
scenario scenario{"door closure/eu07 with a coach", motion() + doors()};
scenario.add("4e_v1/4e", 1).add("bdhpumn_v3/bdhpumn");
scenario.start_up();
CHECK(scenario.cab().door_closure() == door_closure_t::none);
scenario.act("open right");
scenario.cab().PermitDoors(side::right, true);
scenario.cab().OperateDoors(side::right, true);
scenario.wait(10.0);
CHECK(scenario.vehicle(1).door_closure() == door_closure_t::open);
CHECK(consist_closure(scenario) == door_closure_t::open);
}
TEST_CASE("door closure: the signalling is switched on by DoorClosureSignal in the Doors section, off without it") {
SUBCASE("without the key") {
vehicle wagon{definition::load("wagon")};
CHECK_FALSE(wagon->Doors.closure_signal);
}
SUBCASE("with the key") {
vehicle wagon{definition::load("wagon").set("Doors", "DoorClosureSignal", "Yes")};
CHECK(wagon->Doors.closure_signal);
}
}
TEST_CASE("door closure: without DoorClosureSignal the lamp shows the lock of the vehicle's own doors, as before") {
vehicle wagon{definition::load("wagon")};
REQUIRE_FALSE(wagon->Doors.closure_signal);
for (auto const locked : {true, false}) {
wagon->Doors.is_locked = locked;
for (auto const consist : {door_closure_t::none, door_closure_t::locked, door_closure_t::released, door_closure_t::open}) {
for (auto const lit : {true, false}) {
CAPTURE(locked);
CAPTURE(static_cast<int>(consist));
CAPTURE(lit);
// no blinking at a standstill with the doors closed, whatever the consist does
CHECK(wagon->door_closure_lamp_lit(consist, lit) == locked);
}
}
}
}
TEST_CASE("door closure: with DoorClosureSignal the lamp shows the consist in three states") {
vehicle wagon{definition::load("wagon").set("Doors", "DoorClosureSignal", "Yes")};
REQUIRE(wagon->Doors.closure_signal);
for (auto const locked : {true, false}) {
// the vehicle's own lock doesn't matter, the consist does
wagon->Doors.is_locked = locked;
for (auto const lit : {true, false}) {
CAPTURE(locked);
CAPTURE(lit);
CHECK(wagon->door_closure_lamp_lit(door_closure_t::locked, lit));
CHECK(wagon->door_closure_lamp_lit(door_closure_t::released, lit) == lit);
CHECK_FALSE(wagon->door_closure_lamp_lit(door_closure_t::open, lit));
CHECK_FALSE(wagon->door_closure_lamp_lit(door_closure_t::none, lit));
}
}
}

View File

@@ -0,0 +1,54 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle/doorwings.h"
// the poses of the animated door wings (eu07/maszyna#512): a wing of the main model and its namesake in the low
// poly interior get the same pose, worked out once from the door position of the mover
TEST_CASE("door wings: only the door animations move wings") {
CHECK(door_wings::is_wing(0x010)); // TAnim::TypeSet for the doors
CHECK_FALSE(door_wings::is_wing(0x000)); // axles
CHECK_FALSE(door_wings::is_wing(0x055)); // pantographs, five submodels
CHECK_FALSE(door_wings::is_wing(0x070)); // doorsteps
CHECK_FALSE(door_wings::is_wing(0x080)); // mirrors
CHECK(door_wings::is_wing(0x210)); // the parameter count in the upper bits doesn't matter
}
TEST_CASE("door wings: odd wings are on the left, even ones on the right") {
CHECK_FALSE(door_wings::on_right_side(1));
CHECK(door_wings::on_right_side(2));
CHECK_FALSE(door_wings::on_right_side(3));
CHECK(door_wings::on_right_side(4));
}
TEST_CASE("door wings: a sliding wing shifts along the vehicle by the door position") {
CHECK(door_wings::slide(0.f) == glm::vec3(0.f, 0.f, 0.f));
CHECK(door_wings::slide(0.65f) == glm::vec3(0.f, 0.f, 0.65f));
}
TEST_CASE("door wings: a plug wing goes out first, then slides") {
auto const rangeout{0.1f};
// closed
CHECK(door_wings::plug(0.f, rangeout) == glm::vec3(0.f, 0.f, 0.f));
// still going out, and not sliding yet
auto const out{door_wings::plug(0.02f, rangeout)};
CHECK(out.x == doctest::Approx(0.04f));
CHECK(out.z == 0.f);
// out as far as it goes, sliding by what the position has beyond half of the way out
auto const open{door_wings::plug(0.7f, rangeout)};
CHECK(open.x == rangeout);
CHECK(open.y == 0.f);
CHECK(open.z == doctest::Approx(0.65f));
}
TEST_CASE("door wings: a folding wing turns one way and its larger wing twice as far the other way") {
auto const angles{door_wings::fold(40.f)};
CHECK(angles.smaller == 40.f);
CHECK(angles.larger == -80.f);
CHECK(angles.step == 40.f);
auto const closed{door_wings::fold(0.f)};
CHECK(closed.smaller == 0.f);
CHECK(closed.larger == 0.f);
CHECK(closed.step == 0.f);
}

View File

@@ -0,0 +1,74 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
// stopping the engine of a diesel shunter like the SM03 (eu07/maszyna#427): its fuel pump starts on its own with the
// engine and the engine runs the converter which feeds the low voltage circuit, so neither the fuel pump switch nor the
// battery switch stop it. the cab has only the starter button, and the command opening the main circuit has to stop it
namespace {
// the shunter with its engine started from the cab and idling
test::vehicle running_shunter() {
test::vehicle shunter{test::definition::load("diesel_shunter")};
shunter->CabOccupied = 1;
shunter->CabActivisation();
shunter->BatterySwitch(true);
shunter->OilPumpSwitch(true);
shunter.run(20.0); // the oil pressure builds up
shunter->MainSwitch(true);
shunter.run(15.0);
return shunter;
}
} // namespace
TEST_CASE("engine shutdown: the shunter starts with the starter button") {
auto shunter{running_shunter()};
REQUIRE(shunter->EngineType == TEngineType::DieselEngine);
REQUIRE(shunter->FuelPump.start_type == start_t::automatic);
CHECK(shunter->Mains);
CHECK(shunter->FuelPump.is_active);
CHECK(shunter->enrot > 0.9 * shunter->dizel_nmin);
}
TEST_CASE("engine shutdown: neither the fuel pump switch nor the battery switch stop the engine") {
auto shunter{running_shunter()};
shunter->FuelPumpSwitchOff(true, range_t::local); // the pump started automatically ignores its switch
shunter.run(10.0);
CHECK(shunter->Mains);
shunter->BatterySwitch(false);
shunter.run(10.0);
CHECK(shunter->Power110vIsAvailable); // the converter run by the engine keeps feeding the fuel pump
CHECK(shunter->Mains);
CHECK(shunter->enrot > 0.9 * shunter->dizel_nmin);
}
TEST_CASE("engine shutdown: the command opening the main circuit stops the engine and it stays stopped") {
auto shunter{running_shunter()};
REQUIRE(shunter->MainCircuitOpensWithStarterOnly()); // the cab passes the command on with only the starter button
CHECK(shunter->MainSwitch(false));
shunter.run(20.0);
CHECK_FALSE(shunter->Mains);
CHECK_FALSE(shunter->FuelPump.is_active);
CHECK(shunter->enrot == 0.0);
}
TEST_CASE("engine shutdown: the engine starts again after it was stopped") {
auto shunter{running_shunter()};
shunter->MainSwitch(false);
shunter.run(20.0);
REQUIRE(shunter->enrot == 0.0);
shunter->MainSwitch(true);
shunter.run(15.0);
CHECK(shunter->Mains);
CHECK(shunter->enrot > 0.9 * shunter->dizel_nmin);
}
TEST_CASE("engine shutdown: vehicles without a diesel keep ignoring the command with only the button closing the circuit") {
test::vehicle wagon{test::definition::load("wagon")};
CHECK_FALSE(wagon->MainCircuitOpensWithStarterOnly());
test::vehicle electric{test::definition::load("wagon").set("Engine", "EngineType", "ElectricSeriesMotor")};
REQUIRE(electric->EngineType == TEngineType::ElectricSeriesMotor);
CHECK_FALSE(electric->MainCircuitOpensWithStarterOnly());
}

View File

@@ -0,0 +1,298 @@
#include "stdafx.h"
#include "doctest.h"
#include "consist.h"
#include "vehicle/enginestart.h"
// starting the engines of the vehicles in multiple from the cab (eu07/maszyna#80): the cab's own switch (main_*) works
// all of them unless Engine:JointEngineStart=No keeps it to its own vehicle, and the switches mainb_* and mainc_* start
// the second and the third vehicle alone. the cab (TTrain) passes the vehicle's MainSwitchRange() to its MainSwitch(),
// finds the vehicles with engine(), and runs remote_switch for the switches of the others
using test::consist;
using test::definition;
namespace {
// the SN61 railcar, whose cab has a set of switches for each of up to three railcars in multiple
definition sn61(bool const Joint = true) {
auto railcar{definition::fiz("sn61_v2/sn61")};
if (false == Joint) {
railcar.set("Engine", "JointEngineStart", "No");
}
return railcar;
}
// the battery, the cab and the pumps of every railcar of the train switched on from the first one's cab, the oil
// pressure built up, and the controller at the first position giving the engines fuel, which a mechanical diesel
// starts at: everything but the engines ready to start
void prepare(consist &Train) {
auto &cab{Train[0].mover()};
cab.BatterySwitch(true);
cab.CabActivisation();
cab.OilPumpSwitch(true);
cab.FuelPumpSwitch(true);
while (cab.RList[cab.MainCtrlPos].R == 0.0 && cab.IncMainCtrl(1)) {
// up to the first position with fuel
}
Train.run(20.0);
}
bool running(TMoverParameters const &Vehicle) {
return Vehicle.Mains && Vehicle.enrot > 0.5 * Vehicle.dizel_nmin;
}
// the time step of the train in the loops below
auto const dt{0.01};
// the count of the steps of dt making up Seconds
int steps(double const Seconds) {
return static_cast<int>(std::lround(Seconds / dt));
}
// the switch of Engine held closed for Seconds, then let go, in steps of the train
void hold(consist &Train, engine_start::remote_switch &Switch, TMoverParameters *Engine, double const Seconds, bool const Closesonrelease = false) {
for (auto step = 0; step < steps(Seconds); ++step) {
Switch.update(Engine, true, false, dt, Closesonrelease);
Train.step({}, dt);
}
Switch.update(Engine, false, false, dt, Closesonrelease);
}
} // namespace
TEST_CASE("engine start: the joint start is the default, and JointEngineStart=No keeps the cab's switch to its vehicle") {
consist train;
auto const &joint{train.add(sn61(), 1).mover()};
auto const &separate{train.add(sn61(false)).mover()};
CHECK(joint.JointEngineStart);
CHECK_FALSE(separate.JointEngineStart);
CHECK(joint.MainSwitchRange() == range_t::consist);
CHECK(separate.MainSwitchRange() == range_t::local);
}
TEST_CASE("engine start: the vehicles in multiple, counted from the cab's own one, those behind the cab first") {
consist train;
auto &first{train.add(sn61(), 1).mover()};
auto &second{train.add(sn61()).mover()};
auto &third{train.add(sn61()).mover()};
CHECK(engine_start::engine(first, first, 1) == &first);
CHECK(engine_start::engine(first, first, 2) == &second);
CHECK(engine_start::engine(first, first, 3) == &third);
CHECK(engine_start::engine(first, first, 4) == nullptr);
CHECK(engine_start::engine(first, first, 0) == nullptr);
// from the rear cab of the first railcar the others are in front of the cab, in the same order
first.CabOccupied = -1;
CHECK(engine_start::engine(first, first, 2) == &second);
CHECK(engine_start::engine(first, first, 3) == &third);
// from the middle one, the one behind its cab comes first
second.CabOccupied = 1;
CHECK(engine_start::engine(second, second, 2) == &third);
CHECK(engine_start::engine(second, second, 3) == &first);
second.CabOccupied = -1;
CHECK(engine_start::engine(second, second, 2) == &first);
CHECK(engine_start::engine(second, second, 3) == &third);
}
TEST_CASE("engine start: only the vehicles with an engine and under control through the cable count") {
consist train;
auto &first{train.add(sn61(), 1).mover()};
// a vehicle without an engine between the railcars is passed over
auto &trailer{train.add(definition::fiz("ed72_v1/5bs-ra")).mover()};
auto &second{train.add(sn61()).mover()};
REQUIRE(trailer.Power < 0.01);
CHECK(engine_start::engine(first, first, 2) == &second);
// the vehicle with the cab doesn't drive itself: its engine is in the vehicle it controls, which isn't counted twice
trailer.CabOccupied = 1;
CHECK(engine_start::engine(trailer, first, 1) == &first);
CHECK(engine_start::engine(trailer, first, 2) == &second);
CHECK(engine_start::engine(trailer, first, 3) == nullptr);
// coupled without the control cable, the other railcar isn't under the cab's control
consist apart;
auto &alone{apart.add(sn61(), 1).mover()};
apart.add(sn61(), 0, coupling::coupler | coupling::brakehose);
CHECK(engine_start::engine(alone, alone, 2) == nullptr);
}
TEST_CASE("engine start: by default the cab's switch starts and stops the engines of all the vehicles in multiple") {
consist train;
auto &first{train.add(sn61(), 1).mover()};
auto const &second{train.add(sn61()).mover()};
prepare(train);
REQUIRE_FALSE(first.Mains);
REQUIRE_FALSE(second.Mains);
first.MainSwitch(true, first.MainSwitchRange());
train.run(15.0);
CHECK(running(first));
CHECK(running(second));
first.MainSwitch(false, first.MainSwitchRange());
train.run(5.0);
CHECK_FALSE(first.Mains);
CHECK_FALSE(second.Mains);
}
TEST_CASE("engine start: with JointEngineStart=No each engine has its own switch") {
consist train;
auto &first{train.add(sn61(false), 1).mover()};
auto &second{train.add(sn61(false)).mover()};
auto &third{train.add(sn61(false)).mover()};
prepare(train);
// the cab's own switch starts its own engine only
first.MainSwitch(true, first.MainSwitchRange());
train.run(15.0);
REQUIRE(running(first));
CHECK_FALSE(second.Mains);
CHECK_FALSE(third.Mains);
// the second one's switch, mainb_*, starts the second engine
engine_start::remote_switch switchb;
engine_start::remote_switch switchc;
auto *engineb{engine_start::engine(first, first, 2)};
auto *enginec{engine_start::engine(first, first, 3)};
REQUIRE(engineb == &second);
REQUIRE(enginec == &third);
hold(train, switchb, engineb, 2.0); // past the SN61's delay of 1.5 s
train.run(15.0);
CHECK(running(second));
CHECK_FALSE(third.Mains);
// and the third one's, mainc_*, the third
hold(train, switchc, enginec, 2.0);
train.run(15.0);
CHECK(running(third));
// the switches open their own vehicles' circuits only
CHECK(engine_start::remote_switch::open(second));
train.run(5.0);
CHECK_FALSE(second.Mains);
CHECK(running(first));
CHECK(running(third));
first.MainSwitch(false, first.MainSwitchRange());
train.run(5.0);
CHECK_FALSE(first.Mains);
CHECK(running(third));
CHECK_FALSE(engine_start::remote_switch::open(second)); // already stopped
}
TEST_CASE("engine start: the switch of another vehicle is held for the vehicle's delay, with the vehicle ready") {
consist train;
train.add(sn61(false).set("Cntrl", "IniCDelay", "2.0"), 1);
auto &second{train.add(sn61(false).set("Cntrl", "IniCDelay", "2.0")).mover()};
REQUIRE(second.InitialCtrlDelay == doctest::Approx(2.0));
engine_start::remote_switch switchb;
// without the battery the switch does nothing, however long it's held
hold(train, switchb, &second, 5.0);
train.run(5.0);
CHECK_FALSE(second.Mains);
CHECK_FALSE(second.dizel_startup);
prepare(train);
// let go too early
hold(train, switchb, &second, 1.0);
CHECK_FALSE(engine_start::remote_switch::is_running(second));
// the switch opening the circuit held along, the closing one does nothing
for (auto step = 0; step < steps(3.0); ++step) {
switchb.update(&second, true, true, dt, false);
train.step({}, dt);
}
CHECK_FALSE(engine_start::remote_switch::is_running(second));
// held long enough
hold(train, switchb, &second, 2.5);
CHECK(engine_start::remote_switch::is_running(second));
train.run(15.0);
CHECK(running(second));
}
TEST_CASE("engine start: a switch closing on release, as an electric locomotive's impulse switch, waits to be let go") {
consist train;
train.add(sn61(false), 1);
auto &second{train.add(sn61(false).set("Cntrl", "IniCDelay", "1.0")).mover()};
prepare(train);
engine_start::remote_switch switchb;
// held past the delay, the circuit stays open while the switch is held
for (auto step = 0; step < steps(2.0); ++step) {
switchb.update(&second, true, false, dt, true);
train.step({}, dt);
}
CHECK_FALSE(engine_start::remote_switch::is_running(second));
// and closes when let go
switchb.update(&second, false, false, dt, true);
CHECK(engine_start::remote_switch::is_running(second));
train.run(15.0);
REQUIRE(running(second));
// let go before the delay, it doesn't
CHECK(engine_start::remote_switch::open(second));
train.run(5.0);
REQUIRE_FALSE(engine_start::remote_switch::is_running(second));
hold(train, switchb, &second, 0.5, true);
CHECK_FALSE(engine_start::remote_switch::is_running(second));
}
TEST_CASE("engine start: an engine stopping on its own stops the others only when they started together") {
for (auto const joint : {true, false}) {
CAPTURE(joint);
consist train;
auto &first{train.add(sn61(joint), 1).mover()};
auto const &second{train.add(sn61(joint)).mover()};
prepare(train);
engine_start::remote_switch switchb;
first.MainSwitch(true, first.MainSwitchRange());
hold(train, switchb, engine_start::engine(first, first, 2), 2.0);
train.run(15.0);
REQUIRE(running(first));
REQUIRE(running(second));
// the first one's fuel cut off, its engine stops
first.FuelPump.is_disabled = true;
train.run(15.0);
CHECK_FALSE(first.Mains);
CHECK(first.enrot == 0.0);
// started on their own, the others keep running
CHECK(running(second) == (false == joint));
}
}
// a stopped engine stays stopped on its own: only an engine stopping while it ran tells the others, as a joint start's
// engines stop together; one stopped from another vehicle's switch, or not started at all, doesn't stop those running,
// whatever the flags of the vehicles in a mixed train
TEST_CASE("engine start: an engine stopped from its own switch doesn't stop the others when it has spun down") {
consist train;
// the middle railcar keeps the joint start, as a .fiz without the key does. what a vehicle without the cab relays
// goes on away from the cab, so it's the third one that would stop
auto &first{train.add(sn61(false), 1).mover()};
auto &second{train.add(sn61()).mover()};
auto &third{train.add(sn61(false)).mover()};
prepare(train);
engine_start::remote_switch switchb;
engine_start::remote_switch switchc;
first.MainSwitch(true, first.MainSwitchRange());
hold(train, switchb, engine_start::engine(first, first, 2), 2.0);
hold(train, switchc, engine_start::engine(first, first, 3), 2.0);
train.run(15.0);
REQUIRE(running(first));
REQUIRE(running(second));
REQUIRE(running(third));
// mainb_off
CHECK(engine_start::remote_switch::open(second));
train.run(30.0);
CHECK_FALSE(second.Mains);
CHECK(second.enrot == 0.0);
CHECK(running(first));
CHECK(running(third));
}
TEST_CASE("engine start: the stopped engine of the cab's vehicle doesn't stop the one started from its switch") {
consist train;
// the cab's railcar keeps the joint start, its engine stopped
auto &first{train.add(sn61(), 1).mover()};
auto &second{train.add(sn61(false)).mover()};
prepare(train);
REQUIRE_FALSE(first.Mains);
// mainb_on
engine_start::remote_switch switchb;
hold(train, switchb, engine_start::engine(first, first, 2), 2.0);
train.run(15.0);
CHECK(running(second));
CHECK_FALSE(first.Mains);
CHECK(first.enrot == 0.0);
}

View File

@@ -0,0 +1,110 @@
#include "stdafx.h"
#include "doctest.h"
#include "utilities/framepacer.h"
// the main loop's frame limiter (fpslimit in eu07.ini, eu07/maszyna#416), driven with made-up clock readings
namespace
{
using namespace std::chrono_literals;
using clock_type = frame_pacer::clock;
clock_type::time_point const kStart{clock_type::time_point{} + 100s};
constexpr clock_type::duration kFrame{std::chrono::duration_cast<clock_type::duration>(std::chrono::duration<float>(1.f / 30.f))};
// runs frames that take Work each, with every wait overshooting by Oversleep; returns when the last of Frames ends
clock_type::time_point run_frames(frame_pacer &Pacer, int const Frames, clock_type::duration const Work, clock_type::duration const Oversleep)
{
auto now{kStart};
for (auto frame = 0; frame < Frames; ++frame)
{
now += Work;
if (auto const next{Pacer.next_frame(now, kFrame)})
{
CHECK(*next > now);
now = *next + Oversleep;
}
}
return now;
}
} // namespace
TEST_CASE("frame pacer: without a limit nothing waits")
{
frame_pacer pacer;
CHECK_FALSE(pacer.next_frame(kStart, clock_type::duration::zero()).has_value());
CHECK_FALSE(pacer.next_frame(kStart + 1ms, clock_type::duration::zero()).has_value());
}
TEST_CASE("frame pacer: a quick frame waits out the rest of the frame time")
{
frame_pacer pacer;
// the first frame only sets the cadence
CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value());
auto const next{pacer.next_frame(kStart + 5ms, kFrame)};
REQUIRE(next.has_value());
CHECK(*next == kStart + kFrame);
}
TEST_CASE("frame pacer: a slow frame doesn't wait")
{
frame_pacer pacer;
CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value());
CHECK_FALSE(pacer.next_frame(kStart + kFrame + 5ms, kFrame).has_value());
}
TEST_CASE("frame pacer: the frame rate holds the limit with fast frames")
{
frame_pacer pacer;
auto const end{run_frames(pacer, 301, 2ms, clock_type::duration::zero())};
// 300 paced frames after the first
CHECK(end == kStart + 2ms + 300 * kFrame);
}
TEST_CASE("frame pacer: a wait that overshoots is made up in the next frame")
{
// the windows timer wakes a sleeping thread up to ~15.6 ms late; sleeping off what is left of each frame
// then drops 30 fps to about 22. on a fixed cadence the frame rate still averages to the limit
frame_pacer pacer;
auto const end{run_frames(pacer, 301, 2ms, 12ms)};
auto const elapsed{std::chrono::duration<double>(end - kStart).count()};
CHECK(300.0 / elapsed == doctest::Approx(30.0).epsilon(0.01));
}
TEST_CASE("frame pacer: after a long frame the cadence starts anew instead of catching up")
{
frame_pacer pacer;
CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value());
// a hitch of half a second
auto const late{kStart + 500ms};
CHECK_FALSE(pacer.next_frame(late, kFrame).has_value());
// the next quick frame waits a whole frame time from there rather than running at once
auto const next{pacer.next_frame(late + 1ms, kFrame)};
REQUIRE(next.has_value());
CHECK(*next == late + kFrame);
}
TEST_CASE("frame pacer: turning the limit off and on again starts a new cadence")
{
frame_pacer pacer;
CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value());
CHECK_FALSE(pacer.next_frame(kStart + 1ms, clock_type::duration::zero()).has_value());
CHECK_FALSE(pacer.next_frame(kStart + 2s, kFrame).has_value());
auto const next{pacer.next_frame(kStart + 2s + 1ms, kFrame)};
REQUIRE(next.has_value());
CHECK(*next == kStart + 2s + kFrame);
}
TEST_CASE("frame pacer: the wait stays exact after days of system uptime")
{
// fpslimit 60 gives the frame time as float seconds; the old limiter handed the float rest of the frame
// to sleep_for, which adds it to steady_clock::now() in float nanoseconds. after 95 hours of uptime that
// rounds the wake-up time to steps of ~33 ms, and a 14 ms wait came out as no wait at all
frame_pacer pacer;
std::chrono::duration<float> const frametime{1.f / 60.f};
auto const uptime{clock_type::time_point{} + 95h};
CHECK_FALSE(pacer.next_frame(uptime, frametime).has_value());
auto const next{pacer.next_frame(uptime + 2ms, frametime)};
REQUIRE(next.has_value());
auto const wait{std::chrono::duration<double, std::milli>(*next - (uptime + 2ms)).count()};
CHECK(wait == doctest::Approx(1000.0 / 60.0 - 2.0).epsilon(0.001));
}

View File

@@ -0,0 +1,53 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle/gaugeduplicates.h"
// cab controls with more than one submodel (eu07/maszyna#527): a definition of a control in the .mmd marked
// "duplicate: yes" adds a copy of the control already defined in the cab, instead of replacing it. TGauge itself
// (3d models, sounds) is not part of the core library, the rule which decides it is
namespace {
// stand-ins for the 3d models of the cab
struct model {};
} // namespace
TEST_CASE("gauge duplicates: the values of the duplicate key which mark a duplicate") {
CHECK(gauge_duplicates::is_duplicate("yes"));
CHECK(gauge_duplicates::is_duplicate("true"));
CHECK(gauge_duplicates::is_duplicate("1"));
CHECK_FALSE(gauge_duplicates::is_duplicate("no"));
CHECK_FALSE(gauge_duplicates::is_duplicate("false"));
CHECK_FALSE(gauge_duplicates::is_duplicate("0"));
CHECK_FALSE(gauge_duplicates::is_duplicate(""));
}
TEST_CASE("gauge duplicates: a duplicate adds a copy to the control loaded from either model of the cab") {
model cab;
model lowpoly;
CHECK(gauge_duplicates::adds_copy<model>(true, &cab, &cab, &lowpoly));
CHECK(gauge_duplicates::adds_copy<model>(true, &lowpoly, &cab, &lowpoly));
// a cab without a low poly interior
CHECK(gauge_duplicates::adds_copy<model>(true, &cab, &cab, nullptr));
}
TEST_CASE("gauge duplicates: a definition not marked as a duplicate replaces the control, as before") {
model cab;
model lowpoly;
CHECK_FALSE(gauge_duplicates::adds_copy<model>(false, &cab, &cab, &lowpoly));
CHECK_FALSE(gauge_duplicates::adds_copy<model>(false, nullptr, &cab, &lowpoly));
}
TEST_CASE("gauge duplicates: with nothing loaded in this cab a duplicate is the control itself") {
model cab;
model lowpoly;
model previouscab;
// the control isn't defined before it
CHECK_FALSE(gauge_duplicates::adds_copy<model>(true, nullptr, &cab, &lowpoly));
CHECK_FALSE(gauge_duplicates::adds_copy<model>(true, nullptr, &cab, nullptr));
// the control is left over from the cab loaded before
CHECK_FALSE(gauge_duplicates::adds_copy<model>(true, &previouscab, &cab, &lowpoly));
CHECK_FALSE(gauge_duplicates::adds_copy<model>(true, &previouscab, &cab, nullptr));
}

View File

@@ -0,0 +1,30 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle/holdcoillever.h"
// the lever of the line breaker's hold coil on the ET22 and the EP09 stays where it's put (eu07/maszyna#364), when the
// cab declares its main_off_bt control with "type: toggle"; otherwise main_off_bt is the push button it always was
TEST_CASE("hold coil lever: only a main_off_bt declared as a toggle switch is the bistable lever (eu07/maszyna#364)") {
CHECK(hold_coil_lever::is_bistable(true, true));
// declared as a push button
CHECK_FALSE(hold_coil_lever::is_bistable(true, false));
// no type given: a control defaults to the toggle type, which existing cabs relied on for the push button
CHECK_FALSE(hold_coil_lever::is_bistable(false, true));
}
TEST_CASE("hold coil lever: operated, it goes over to the other position and stays there") {
// on: the hold coil fed, the line breaker can close
CHECK_FALSE(hold_coil_lever::cuts_off(0.f));
auto const off{hold_coil_lever::operated(0.f)};
CHECK(off == doctest::Approx(1.f));
CHECK(hold_coil_lever::cuts_off(off));
// operated again it goes back on
auto const on{hold_coil_lever::operated(off)};
CHECK(on == doctest::Approx(0.f));
CHECK_FALSE(hold_coil_lever::cuts_off(on));
// caught on the way between the positions it goes to the far one
CHECK(hold_coil_lever::operated(0.3f) == doctest::Approx(1.f));
CHECK(hold_coil_lever::operated(0.7f) == doctest::Approx(0.f));
}

View File

@@ -0,0 +1,96 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
// the cab interior light set by the positions of the light preset selector: an optional third column of LightsList,
// 1 the cab light on, 2 dimmed, 0 off; a row without it leaves the cab light to its own switch (eu07/maszyna#529)
using test::definition;
using test::vehicle;
namespace {
auto const shunting{light::headlight_left | light::headlight_right};
} // namespace
TEST_CASE("lights preset cab light: a table without the column sets no position's cab light") {
vehicle wagon{definition::load("wagon")
.set("LightsList", "Size", 2)
.set("LightsList", "Default", 1)
.set("LightsList", "rows", {{0, 0}, {shunting, shunting}})};
REQUIRE(wagon->LightsPosNo == 2);
CHECK(wagon->Lights[end::front][1] == shunting);
CHECK_FALSE(wagon->LightsPresetCabLight(1).has_value());
CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value());
}
TEST_CASE("lights preset cab light: the third column turns the cab light off, on, or on dimmed") {
// off - shunting - shunting with the cab lit - shunting with the cab lit dimmed - shunting leaving the cab light
vehicle wagon{definition::load("wagon")
.set("LightsList", "Size", 5)
.set("LightsList", "Default", 1)
.set("LightsList", "rows", {{0, 0, 0}, {shunting, shunting}, {shunting, shunting, 1}, {shunting, shunting, 3}, {shunting, 0, -1}})};
REQUIRE(wagon->LightsPosNo == 5);
// the light columns read as before
CHECK(wagon->Lights[end::front][2] == shunting);
CHECK(wagon->Lights[end::rear][2] == shunting);
CHECK(wagon->Lights[end::rear][4] == 0);
auto const off{wagon->LightsPresetCabLight(1)};
REQUIRE(off.has_value());
CHECK_FALSE(off->light);
CHECK_FALSE(off->dim);
CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value());
auto const lit{wagon->LightsPresetCabLight(3)};
REQUIRE(lit.has_value());
CHECK(lit->light);
CHECK_FALSE(lit->dim);
auto const dimmed{wagon->LightsPresetCabLight(4)};
REQUIRE(dimmed.has_value());
CHECK(dimmed->light);
CHECK(dimmed->dim);
// a negative value is the same as no value
CHECK_FALSE(wagon->LightsPresetCabLight(5).has_value());
}
TEST_CASE("lights preset cab light: positions outside the table, and the lightsset custom one, set nothing") {
vehicle wagon{definition::load("wagon")
.set("LightsList", "Size", 1)
.set("LightsList", "Default", 1)
.set("LightsList", "rows", {{shunting, shunting, 1}})};
CHECK(wagon->LightsPresetCabLight(1).has_value());
CHECK_FALSE(wagon->LightsPresetCabLight(0).has_value());
CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value());
CHECK_FALSE(wagon->LightsPresetCabLight(18).has_value());
CHECK_FALSE(wagon->LightsPresetCabLight(19).has_value());
}
TEST_CASE("lights preset cab light: a stray note after the two columns is not read as the cab light") {
// some vehicles of the game carry rows like "38 38 / A"
auto text{definition::load("wagon")
.set("LightsList", "Size", 2)
.set("LightsList", "Default", 1)
.set("LightsList", "rows", {{0, 0}, {38, 38}})
.text()};
auto const list{text.find("LightsList")};
REQUIRE(list != std::string::npos);
auto const row{text.find("38", list)};
REQUIRE(row != std::string::npos);
auto const rowend{text.find('\n', row)};
REQUIRE(rowend != std::string::npos);
text.insert(rowend, " / A");
TMoverParameters wagon(0.0, "wagon", "test", 0);
REQUIRE(wagon.LoadFIZ_Text(text));
REQUIRE(wagon.LightsPosNo == 2);
CHECK(wagon.Lights[end::front][1] == 38);
CHECK(wagon.Lights[end::rear][1] == 38);
CHECK_FALSE(wagon.LightsPresetCabLight(2).has_value());
}

View File

@@ -0,0 +1,93 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle/lightsprogrammer.h"
// the lights the light preset selector (programmer) of the occupied cab gives the vehicles of the consist,
// TDynamicObject::SetLights(): the cab's front lights at the end the cab faces, its back lights at the other
// end, and no lights at an end with another vehicle coupled
namespace {
int const pc1{light::headlight_left | light::headlight_upper | light::headlight_right};
int const tailmarkers{light::redmarker_left | light::redmarker_right};
std::array<int, 2> const cablights{pc1, tailmarkers}; // Lights[end::front], Lights[end::rear]
// the lights at the vehicle's own end, placed the way TDynamicObject::RaLightsSet() places them
int lights_at(lights_programmer::consist_lights const &Lights, int const Direction, end const Side) {
auto const headend{Direction > 0 ? end::front : end::rear};
return Side == headend ? Lights.head : Lights.rear;
}
struct setup {
int cab; // CabOccupied of the vehicle with the programmer
int direction; // its iDirection
std::array<bool, 2> coupled; // vehicle coupled at its end::front / end::rear
};
lights_programmer::consist_lights lights_for(setup const &Setup) {
// TDynamicObject::SetLights(): the cab faces the head of the consist when CabOccupied * DirectionGet() >= 0
auto const cabfacinghead{Setup.cab * (Setup.direction > 0 ? 1 : -1) >= 0};
return lights_programmer::vehicle_lights(cablights, cabfacinghead, Setup.direction, Setup.coupled);
}
} // namespace
TEST_CASE("lights programmer: a lone vehicle gets the cab's front lights ahead of the cab and its back lights behind it") {
for (auto const direction : {0, 1}) {
CAPTURE(direction);
// cab 1 faces end::front
auto const fromcab1{lights_for({1, direction, {false, false}})};
CHECK(lights_at(fromcab1, direction, end::front) == pc1);
CHECK(lights_at(fromcab1, direction, end::rear) == tailmarkers);
// cab -1 faces end::rear
auto const fromcab2{lights_for({-1, direction, {false, false}})};
CHECK(lights_at(fromcab2, direction, end::rear) == pc1);
CHECK(lights_at(fromcab2, direction, end::front) == tailmarkers);
}
}
TEST_CASE("lights programmer: the end with the train coupled goes dark, not the other one (eu07/maszyna#395)") {
// a locomotive driven from either cab, with the train coupled at either end, either way round in the consist.
// the end with the train goes dark, the free end shows the lights meant for it
for (auto const direction : {0, 1}) {
for (auto const cab : {1, -1}) {
for (auto const trainend : {end::front, end::rear}) {
CAPTURE(direction);
CAPTURE(cab);
CAPTURE(trainend);
std::array<bool, 2> coupled{false, false};
coupled[trainend] = true;
auto const freeend{trainend == end::front ? end::rear : end::front};
auto const cabfront{cab > 0 ? end::front : end::rear};
auto const lights{lights_for({cab, direction, coupled})};
CHECK(lights_at(lights, direction, trainend) == 0);
CHECK(lights_at(lights, direction, freeend) == (freeend == cabfront ? pc1 : tailmarkers));
}
}
}
}
TEST_CASE("lights programmer: 6Dg driven backwards from its second cab position pulls the train with its head lights lit (eu07/maszyna#395)") {
// the reported case: the train coupled behind the driver (end::front, which cab -1 has at its back), the
// locomotive running towards end::rear, the train in tow. the head lights stay lit, the end with the train goes dark;
// before the fix the couplings were looked up at the swapped ends and it was the other way round
auto const lights{lights_for({-1, 1, {true, false}})};
CHECK(lights_at(lights, 1, end::rear) == pc1);
CHECK(lights_at(lights, 1, end::front) == 0);
}
TEST_CASE("lights programmer: a vehicle coupled at both ends stays dark") {
for (auto const direction : {0, 1}) {
for (auto const cab : {1, -1}) {
CAPTURE(direction);
CAPTURE(cab);
auto const lights{lights_for({cab, direction, {true, true}})};
CHECK(lights.head == 0);
CHECK(lights.rear == 0);
}
}
}

View File

@@ -57,3 +57,74 @@ TEST_CASE("line contactors: the ground relay and overload lamps follow the same
vehicle->MotorConnectorsCheck();
CHECK_FALSE(vehicle->MainCircuitLampsEnabled());
}
// on the diesel-electric SU45 and SU46 (eu07/maszyna#263) the lamp tells just the line contactors are open: lit with the
// master controller at 0 and with the start cut off by too low a pressure in the main pipe, out on the power positions
namespace {
// the diesel-electric locomotive with its engine running and the brakes released, the master controller at 0
test::vehicle diesel_electric() {
test::vehicle vehicle{test::definition::load("diesel_electric")};
vehicle->CabOccupied = 1;
vehicle->CabActivisation();
vehicle->BatterySwitch(true);
vehicle->OilPumpSwitch(true);
vehicle->FuelPumpSwitch(true);
vehicle.run(20.0); // the oil pressure builds up
vehicle.hold_brake_pipe(5.0); // bar
vehicle->MainSwitch(true);
vehicle.run(30.0);
vehicle->DirectionForward();
vehicle.run(60.0); // the brakes release
return vehicle;
}
} // namespace
TEST_CASE("line contactors: on a diesel-electric the lamp is lit at 0 and goes out on a power position") {
auto vehicle{diesel_electric()};
REQUIRE(vehicle->EngineType == TEngineType::DieselElectric);
REQUIRE(vehicle->Mains);
REQUIRE_FALSE(vehicle->ControlPressureSwitch);
CHECK_FALSE(vehicle->StLinFlag);
CHECK(vehicle->LineContactorsLampLit());
vehicle->IncMainCtrl(1);
vehicle.run(3.0);
CHECK(vehicle->StLinFlag);
CHECK_FALSE(vehicle->LineContactorsLampLit());
vehicle->DecMainCtrl(1);
vehicle.run(3.0);
CHECK_FALSE(vehicle->StLinFlag);
CHECK(vehicle->LineContactorsLampLit());
}
TEST_CASE("line contactors: on a diesel-electric the lamp lights with the contactors opened by too low a main pipe pressure") {
auto vehicle{diesel_electric()};
vehicle->IncMainCtrl(1);
vehicle.run(1.0);
vehicle->IncMainCtrl(1);
vehicle.run(2.0);
REQUIRE(vehicle->StLinFlag);
vehicle.hold_brake_pipe(2.5); // bar, below the 3.6 bar of the pressure switch
vehicle.run(10.0);
REQUIRE(vehicle->ControlPressureSwitch);
CHECK_FALSE(vehicle->StLinFlag);
CHECK(vehicle->LineContactorsLampLit()); // it went out here
CHECK_FALSE(vehicle->MainCircuitLampsEnabled()); // the ground relay and overload lamps still go out with the start cut off
// the pressure back, the contactors stay open on the second position and the lamp stays lit, as it should;
// they close again only on the first one
vehicle.hold_brake_pipe(5.0);
vehicle.run(60.0);
REQUIRE_FALSE(vehicle->ControlPressureSwitch);
CHECK_FALSE(vehicle->StLinFlag);
CHECK(vehicle->LineContactorsLampLit());
vehicle->DecMainCtrl(1);
vehicle.run(3.0);
CHECK(vehicle->StLinFlag);
CHECK_FALSE(vehicle->LineContactorsLampLit());
}

View File

@@ -0,0 +1,114 @@
#include "stdafx.h"
#include "doctest.h"
#include "consist.h"
#include "drive.h"
#include "vehicle/linebreaker.h"
// the line breaker (WS) controls of the cab (eu07/maszyna#394)
using test::consist;
using test::definition;
namespace {
// the line breaker lever of the EP05 (main_sw), a single two-state lever, the way TTrain works it: the state
// the cab keeps of the line breaker follows the vehicle, the breaker closes while the lever is on and can close
struct lever {
TMoverParameters &mover;
int breaker{0}; // as TTrain::m_linebreakerstate: 0 open, 1 closed
bool on{false};
void press() {
switch (linebreaker::pressed(breaker, true, on)) {
case linebreaker::toggle::close:
on = true;
break;
case linebreaker::toggle::open:
on = false;
if (breaker == 1 && mover.MainSwitch(false)) {
breaker = 0;
}
break;
default:
break;
}
}
// TTrain::Update()
void update() {
if (breaker == 0 && mover.Mains) {
breaker = 1;
}
if (breaker == 1 && false == mover.Mains) {
breaker = 0;
}
if (on && breaker == 0 && mover.MainSwitchCheck()) {
breaker = mover.MainSwitch(true) ? 1 : 0;
}
}
};
} // namespace
TEST_CASE("line breaker: a press of the toggle closes an open breaker and opens a closed one") {
using enum linebreaker::toggle;
for (auto const latching : {false, true}) {
CHECK(linebreaker::pressed(0, latching, false) == close);
CHECK(linebreaker::pressed(1, latching, true) == open);
CHECK(linebreaker::pressed(1, latching, false) == open);
// freshly closed, the cab finishes closing it first
CHECK(linebreaker::pressed(2, latching, true) == none);
}
// a lever left on over an open breaker goes off; push buttons have no position to keep
CHECK(linebreaker::pressed(0, true, true) == open);
CHECK(linebreaker::pressed(0, false, true) == close);
}
TEST_CASE("line breaker: the EP05's lever goes off with the converter overload relay tripped (eu07/maszyna#394)") {
consist train;
auto &ep05{train.add(definition::fiz("ep05_v2/ep05"), 1).mover()};
test::track const line{0.15, 0.0, test::catenary_3kv};
auto const driver{test::driving(train)};
REQUIRE(test::start_up(driver, line));
REQUIRE(ep05.Mains);
REQUIRE(ep05.ConverterFlag);
lever ws{ep05, 1, true};
// the converter overload relay knocks the line breaker out, as the cab does it when the converter is
// switched on together with the compressor; the lever stays on
ep05.ConvOvldFlag = true;
ep05.MainSwitch(false, range_t::local);
ws.update();
REQUIRE_FALSE(ep05.Mains);
REQUIRE(ws.breaker == 0);
CHECK(ws.on);
// with the relay tripped the breaker doesn't close
test::drive(driver, line, 5.0);
CHECK_FALSE(ep05.MainSwitchCheck());
// nothing holds the lever: it goes off, and on again, though the breaker stays open
ws.press();
CHECK_FALSE(ws.on);
ws.press();
CHECK(ws.on);
ws.update();
CHECK_FALSE(ep05.Mains);
ws.press();
CHECK_FALSE(ws.on);
// the relay reset, with the converter switched off, the lever put on closes the breaker again
ep05.ConverterSwitch(false, range_t::local);
test::drive(driver, line, 1.0);
CHECK(ep05.RelayReset(relay_t::primaryconverteroverload, range_t::local));
CHECK_FALSE(ep05.ConvOvldFlag);
ws.update();
CHECK_FALSE(ep05.Mains); // the lever is off
ws.press();
ws.update();
CHECK(ep05.Mains);
CHECK(ws.breaker == 1);
// and the next press opens it
ws.press();
CHECK_FALSE(ws.on);
CHECK_FALSE(ep05.Mains);
}

View File

@@ -0,0 +1,55 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
using test::definition;
using test::vehicle;
// the oil pump lamp of the cab (i-oilpump) shows OilPump.is_active: the pre-lubrication pump of 401Da, which works
// before the engine start and stops once the engine runs and makes the oil pressure itself (eu07/maszyna#546)
// NOTE: the test vehicle has no diesel engine, so the pump check is called the way dizel_Update() calls it
TEST_CASE("oil pump: the pre-lubrication pump works before the engine start and stops once the engine runs") {
vehicle loco{definition::load("cab_vehicle").set("Cntrl", "OilStart", "Manual")};
REQUIRE(loco->OilPump.start_type == start_t::manual);
loco->Power24vIsAvailable = true; // battery on
loco->OilPumpCheck(0.01);
CHECK_FALSE(loco->OilPump.is_active); // not switched on yet
loco->OilPump.is_enabled = true; // pump switch on: pre-lubrication
loco->OilPumpCheck(0.01);
CHECK(loco->OilPump.is_active);
loco->Mains = true; // engine started
loco->OilPumpCheck(0.01);
CHECK_FALSE(loco->OilPump.is_active);
}
TEST_CASE("oil pump: the pump started with the engine start procedure stops once the engine runs") {
vehicle loco{definition::load("cab_vehicle").set("Cntrl", "OilStart", "Automatic")};
REQUIRE(loco->OilPump.start_type == start_t::automatic);
loco->Power24vIsAvailable = true;
loco->dizel_startup = true; // starter button pressed
loco->OilPumpCheck(0.01);
CHECK(loco->OilPump.is_active);
loco->dizel_startup = false; // start procedure done, the pump keeps working until the engine runs
loco->OilPumpCheck(0.01);
CHECK(loco->OilPump.is_active);
loco->Mains = true;
loco->OilPumpCheck(0.01);
CHECK_FALSE(loco->OilPump.is_active);
}
TEST_CASE("oil pump: without power the pump and its lamp stay off") {
vehicle loco{definition::load("cab_vehicle")};
loco->Power24vIsAvailable = false;
loco->Power110vIsAvailable = false;
loco->OilPump.is_enabled = true;
loco->OilPumpCheck(0.01);
CHECK_FALSE(loco->OilPump.is_active);
}

View File

@@ -26,3 +26,33 @@ TEST_CASE("radio: a radio switched off or without the low voltage doesn't") {
}
CHECK_FALSE(vehicle->RadioPowered());
}
// the cut-off in the radio's power supply (eu07/maszyna#438): a fuse, a desk lever or the switch on the radio's
// power supply, closed unless the driver opens it
TEST_CASE("radio: the radio fuse is closed by default") {
test::vehicle vehicle{test::definition::load("wagon")};
CHECK(vehicle->RadioFuse);
}
TEST_CASE("radio: an opened radio fuse cuts the radio off") {
test::vehicle vehicle{test::definition::load("wagon")};
vehicle->Radio = true;
vehicle->Power24vIsAvailable = true;
vehicle->RadioFuse = false;
CHECK_FALSE(vehicle->RadioPowered());
vehicle->RadioFuse = true;
CHECK(vehicle->RadioPowered());
}
TEST_CASE("radio: opening the radio fuse at a standstill resets the radio-stop, as switching the radio off does") {
test::vehicle loco{test::definition::fiz("4e_v1/4e")};
loco->Battery = true;
loco->Radio = true;
REQUIRE(loco->RadiostopSwitch(true));
loco->SecuritySystemCheck(0.1);
CHECK(loco->RadioStopFlag);
loco->RadioFuse = false;
loco->SecuritySystemCheck(0.1);
CHECK_FALSE(loco->RadioStopFlag);
}

View File

@@ -2,6 +2,7 @@
#include "doctest.h"
#include "vehicle.h"
#include "drive.h"
#include "vehicle/smoke.h"
@@ -83,3 +84,78 @@ TEST_CASE("smoke: the pending particles never outgrow the room of the source") {
CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, rate, 10.0) == rate.limit);
}
TEST_CASE("smoke: an engine the starter turns lets out no smoke until it fires (#523)") {
auto vehicle{diesel()};
vehicle->dizel_spinup = true;
auto pending{source};
pending.pending = 5.f;
vehicle->dizel_FiringCountdown = 0.5;
CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, pending, update) == 0.f);
vehicle->dizel_FiringCountdown = 0.0;
CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, pending, update) >= 1.f);
}
namespace {
// the locomotive's engine started the way the AI starts it, a second at a time, until it runs (Mains)
bool start_engine(test::driven const &Driven, test::track const &Track) {
for (int second = 0; second < 120 && false == Driven.controlling.Mains; ++second) {
test::start_up(Driven, Track, 1.0);
}
return Driven.controlling.Mains;
}
} // namespace
TEST_CASE("smoke: a real diesel smokes only once its engine has fired, SmokeDelay after the starter began (#523)") {
// a diesel with a mechanical transmission and a diesel-electric one
for (auto const *path : {"sm42_v1/6d1", "st44_v2/m62-1151"}) {
CAPTURE(path);
test::track const track{};
{
// SmokeDelay set in the .fiz of the locomotive
test::vehicle locomotive{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 2)};
REQUIRE(locomotive->dizel_SmokeDelay == doctest::Approx(2.0));
auto const driven{test::driving(locomotive)};
REQUIRE(start_engine(driven, track));
// the engine started less than a second ago: the starter still turns it
CHECK(locomotive->dizel_FiringCountdown > 0.5);
CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) == 0.f);
// it has fired since
test::drive(driven, track, 3.0);
CHECK(locomotive->Mains);
CHECK(locomotive->dizel_FiringCountdown == 0.0);
CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f);
}
{
// a longer delay from the .fiz
test::vehicle locomotive{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 5)};
auto const driven{test::driving(locomotive)};
REQUIRE(start_engine(driven, track));
test::drive(driven, track, 3.0);
CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) == 0.f);
test::drive(driven, track, 3.0);
CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f);
}
}
}
TEST_CASE("smoke: without SmokeDelay in its .fiz a diesel smokes as soon as the starter turns, as before (#523)") {
for (auto const *path : {"sm42_v1/6d1", "st44_v2/m62-1151"}) {
CAPTURE(path);
test::track const track{};
// a locomotive which has the delay, loaded first, doesn't hand it on to the next one: the value is the vehicle's own
test::vehicle delayed{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 3)};
REQUIRE(delayed->dizel_SmokeDelay == doctest::Approx(3.0));
test::vehicle locomotive{test::definition::fiz(path)};
REQUIRE(locomotive->dizel_SmokeDelay == 0.0);
CHECK(delayed->dizel_SmokeDelay == doctest::Approx(3.0));
auto const driven{test::driving(locomotive)};
REQUIRE(start_engine(driven, track));
CHECK(locomotive->dizel_FiringCountdown == 0.0);
CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f);
}
}

View File

@@ -0,0 +1,268 @@
#include "stdafx.h"
#include "doctest.h"
#include "simulation/simulationtestrules.h"
#include <array>
#include <exception>
#include <new>
#include <stdexcept>
#include <vector>
// the test mode of the simulator (eu07 --test, eu07/maszyna#541): its exit codes, command line and end conditions
namespace {
using simulation::test_result;
simulation::test_command_line parse(std::vector<char const *> Arguments)
{
Arguments.insert(Arguments.begin(), "eu07");
return simulation::parse_test_command_line(Arguments);
}
// a frame of the default 0.03 s
simulation::test_frame frame(bool const Atrest, std::optional<double> const Reported = std::nullopt, std::string_view const Reason = {})
{
return simulation::test_frame{0.03, Reported, Reason, Atrest};
}
// runs frames until the test ends or Seconds of simulation time go by
std::optional<simulation::test_verdict> run(simulation::test_progress &Progress, simulation::test_limits const &Limits, double const Seconds,
simulation::test_frame const &Frame)
{
while (Progress.time < Seconds)
{
if (auto verdict{simulation::evaluate_frame(Progress, Frame, Limits)})
return verdict;
}
return std::nullopt;
}
} // namespace
TEST_CASE("test mode: the exit codes keep clear of the ones of a killed or aborted process")
{
std::array const results{test_result::pass, test_result::fail, test_result::signal_passed_at_danger, test_result::timeout, test_result::standstill, test_result::error};
for (auto const result : results)
{
auto const code{static_cast<int>(result)};
CAPTURE(code);
CHECK(code != 1); // TerminateProcess, most programs' failure
CHECK(code != 3); // abort() on Windows
CHECK(code < 126); // shells, signals on Linux
CHECK(simulation::to_string(result) != "unknown");
}
// the codes are public: scripts and CI read them
CHECK(static_cast<int>(test_result::pass) == 0);
CHECK(static_cast<int>(test_result::fail) == 10);
CHECK(static_cast<int>(test_result::signal_passed_at_danger) == 11);
CHECK(static_cast<int>(test_result::timeout) == 12);
CHECK(static_cast<int>(test_result::standstill) == 13);
CHECK(static_cast<int>(test_result::error) == 14);
}
TEST_CASE("test mode: seconds on the command line are a number, not negative")
{
CHECK(simulation::parse_seconds("240").value_or(-1.0) == doctest::Approx(240.0));
CHECK(simulation::parse_seconds("0.5").value_or(-1.0) == doctest::Approx(0.5));
CHECK(simulation::parse_seconds("0").value_or(-1.0) == doctest::Approx(0.0));
CHECK_FALSE(simulation::parse_seconds("").has_value());
CHECK_FALSE(simulation::parse_seconds("-1").has_value());
CHECK_FALSE(simulation::parse_seconds("60s").has_value());
CHECK_FALSE(simulation::parse_seconds("abc").has_value());
CHECK_FALSE(simulation::parse_seconds("inf").has_value());
CHECK_FALSE(simulation::parse_seconds("nan").has_value());
}
TEST_CASE("test mode: the command line")
{
SUBCASE("without --test there is no test")
{
auto const commandline{parse({"-s", "td.scn", "-v", "ep07-424"})};
CHECK_FALSE(commandline.enabled);
CHECK(commandline.error.empty());
}
SUBCASE("--test and its limits, in any order")
{
auto const commandline{parse({"--test-wall-timeout", "900", "-s", "td.scn", "--test", "--test-timeout", "240"})};
CHECK(commandline.enabled);
CHECK(commandline.timeout.value_or(-1.0) == doctest::Approx(240.0));
CHECK(commandline.wall_timeout.value_or(-1.0) == doctest::Approx(900.0));
CHECK(commandline.error.empty());
}
SUBCASE("a limit not given stays unset")
{
auto const commandline{parse({"--test", "-s", "td.scn"})};
CHECK_FALSE(commandline.timeout.has_value());
CHECK_FALSE(commandline.wall_timeout.has_value());
}
SUBCASE("a limit which isn't a number is an error, not a limit turned off")
{
auto const commandline{parse({"--test", "-s", "td.scn", "--test-timeout", "4m"})};
CHECK(commandline.enabled);
CHECK_FALSE(commandline.timeout.has_value());
CHECK(commandline.error == "--test-timeout needs a number of seconds");
}
SUBCASE("a limit without its value is an error")
{
auto const commandline{parse({"--test", "-s", "td.scn", "--test-wall-timeout"})};
CHECK(commandline.error == "--test-wall-timeout needs a number of seconds");
}
SUBCASE("the first error is the one told")
{
auto const commandline{parse({"--test", "--test-timeout", "x", "--test-wall-timeout", "y"})};
CHECK(commandline.error == "--test-timeout needs a number of seconds");
}
SUBCASE("values of other options aren't taken for options")
{
auto const commandline{parse({"-s", "--test", "-ini", "--test-timeout", "-v", "--test-wall-timeout", "-seed", "--test"})};
CHECK_FALSE(commandline.enabled);
CHECK(commandline.error.empty());
}
SUBCASE("-edit takes no option for its scenery, which is optional")
{
// a scenery after -edit or none: the option after it is read either way
CHECK(parse({"-edit", "--test", "-s", "td.scn"}).enabled);
CHECK(parse({"-edit", "td.scn", "--test"}).enabled);
// -edit leaves -s alone, which takes --test for its scenery, as the simulator reads it
CHECK_FALSE(parse({"-edit", "-s", "--test"}).enabled);
}
}
TEST_CASE("test mode: the real time limit")
{
SUBCASE("given, it is the limit, 0 turns it off")
{
CHECK(simulation::wall_clock_limit(120.0, 3600.0) == doctest::Approx(120.0));
CHECK(simulation::wall_clock_limit(0.0, 3600.0) == doctest::Approx(0.0));
}
SUBCASE("not given, it is the simulation time limit and time for the loading")
{
CHECK(simulation::wall_clock_limit(std::nullopt, 240.0) == doctest::Approx(240.0 + simulation::wall_timeout_loading_allowance));
CHECK(simulation::wall_clock_limit(std::nullopt, 3600.0) == doctest::Approx(3600.0 + simulation::wall_timeout_loading_allowance));
}
SUBCASE("no simulation time limit, no real time limit unless given")
{
CHECK(simulation::wall_clock_limit(std::nullopt, 0.0) == doctest::Approx(0.0));
CHECK(simulation::wall_clock_limit(300.0, 0.0) == doctest::Approx(300.0));
}
}
TEST_CASE("test mode: the end conditions")
{
simulation::test_limits limits;
simulation::test_progress progress;
SUBCASE("nothing happens, nothing ends")
{
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false), limits).has_value());
CHECK(progress.time == doctest::Approx(0.03));
CHECK(progress.resttime == doctest::Approx(0.0));
}
SUBCASE("a cell nobody wrote to says nothing")
{
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false, -1.0), limits).has_value());
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false, 2.0), limits).has_value());
CHECK_FALSE(progress.passrequested);
}
SUBCASE("0 fails at once, with the text of the cell")
{
auto const verdict{simulation::evaluate_frame(progress, frame(false, 0.0, "wrong_track"), limits)};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::fail);
CHECK(verdict->reason == "__test.result set to 0 (wrong_track)");
}
SUBCASE("1 passes once the tested trains have stood for a second")
{
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false, 1.0), limits).has_value());
CHECK(progress.passrequested);
// still moving: the pass waits
CHECK_FALSE(run(progress, limits, 30.0, frame(false, 1.0)).has_value());
auto const stoppedat{progress.time};
auto const verdict{run(progress, limits, 60.0, frame(true, 1.0))};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::pass);
CHECK(progress.time - stoppedat == doctest::Approx(simulation::pass_settle_time).epsilon(0.05));
}
SUBCASE("the pass stays requested when the cell changes back")
{
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false, 1.0), limits).has_value());
auto const verdict{run(progress, limits, 60.0, frame(true, -1.0))};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::pass);
}
SUBCASE("1 with test.no_movement_before_pass no passes at once")
{
limits.no_movement_before_pass = false;
auto const verdict{simulation::evaluate_frame(progress, frame(false, 1.0, "reached_the_stop"), limits)};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::pass);
CHECK(verdict->reason == "__test.result set to 1 (reached_the_stop)");
}
SUBCASE("standing still without a result ends after test.standstill")
{
limits.standstill = 120.0;
auto const verdict{run(progress, limits, 1000.0, frame(true))};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::standstill);
CHECK(progress.time == doctest::Approx(120.0).epsilon(0.001));
}
SUBCASE("a move starts the standstill over")
{
limits.standstill = 120.0;
CHECK_FALSE(run(progress, limits, 100.0, frame(true)).has_value());
CHECK_FALSE(simulation::evaluate_frame(progress, frame(false), limits).has_value());
CHECK(progress.resttime == doctest::Approx(0.0));
CHECK_FALSE(run(progress, limits, 200.0, frame(true)).has_value());
}
SUBCASE("test.pass_on_standstill makes the standstill a pass")
{
limits.standstill = 10.0;
limits.pass_on_standstill = true;
auto const verdict{run(progress, limits, 1000.0, frame(true))};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::pass);
}
SUBCASE("test.standstill 0 never ends the test")
{
limits.standstill = 0.0;
limits.timeout = 0.0;
CHECK_FALSE(run(progress, limits, 5000.0, frame(true)).has_value());
}
SUBCASE("no result by test.timeout")
{
limits.timeout = 240.0;
auto const verdict{run(progress, limits, 1000.0, frame(false))};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::timeout);
CHECK(verdict->reason == "no result after 240 s");
CHECK(progress.time == doctest::Approx(240.0).epsilon(0.001));
}
SUBCASE("a result in the last frame wins over the timeout")
{
limits.timeout = 0.03;
auto const verdict{simulation::evaluate_frame(progress, frame(false, 0.0), limits)};
REQUIRE(verdict.has_value());
CHECK(verdict->result == test_result::fail);
}
}
TEST_CASE("test mode: what ended a run the simulator didn't end")
{
SUBCASE("an exception says what it was")
{
CHECK(simulation::describe_exception(std::make_exception_ptr(std::runtime_error("no scenery"))) == "critical error: no scenery");
// e.g. std::stof on a token of a scenery which isn't a number
CHECK(simulation::describe_exception(std::make_exception_ptr(std::invalid_argument("stof"))) == "critical error: stof");
CHECK(simulation::describe_exception(std::make_exception_ptr(std::bad_alloc())).starts_with("critical error: "));
}
SUBCASE("something thrown which isn't a std::exception")
{
CHECK(simulation::describe_exception(std::make_exception_ptr(42)) == "critical error: an exception of unknown type");
}
SUBCASE("terminated without an exception")
{
CHECK(simulation::describe_exception(nullptr) == "the simulator was terminated");
}
}

View File

@@ -0,0 +1,115 @@
#include "stdafx.h"
#include "doctest.h"
#include "vehicle.h"
#include "drive.h"
#include <cmath>
// the universal controller (EIMCtrlType 3) setting its power demand in steps (UCList CtrlValStep), as the 6Dg does
// in steps of 5% (eu07/maszyna#412). the 214M railbus's controller: 3 lowers the power to 0, 4 holds it, 5 raises it
// to 1, at 0.15 a second after IniCDelay (1 s)
using test::definition;
using test::vehicle;
namespace {
constexpr int lower{3};
constexpr int hold{4};
constexpr int raise{5};
// the railbus started up, its brakes released and its direction set, its controller holding no power
void get_ready(vehicle &Railbus, test::track const &Track) {
auto driven{test::driving(Railbus)};
REQUIRE(test::start_up(driven, Track));
test::release_brakes(driven.cab);
for (int i = 0; i < 3 && Railbus->DirActive <= 0; ++i) {
Railbus->DirectionForward();
}
while (Railbus->MainCtrlPos < hold && Railbus->IncMainCtrl(1)) {
;
}
while (Railbus->MainCtrlPos > hold && Railbus->DecMainCtrl(1)) {
;
}
REQUIRE(Railbus->MainCtrlPos == hold);
Railbus.run(2.0, Track);
REQUIRE(Railbus->eimic == doctest::Approx(0.0));
}
void move_to(vehicle &Railbus, int const Position) {
while (Railbus->MainCtrlPos < Position && Railbus->IncMainCtrl(1)) {
;
}
while (Railbus->MainCtrlPos > Position && Railbus->DecMainCtrl(1)) {
;
}
REQUIRE(Railbus->MainCtrlPos == Position);
}
bool on_step(double const Value, double const Step) {
return std::abs(Value / Step - std::round(Value / Step)) < 1e-6;
}
} // namespace
TEST_CASE("controls: the universal controller with CtrlValStep sets its power in whole steps") {
test::track const line{0.15, 0.0};
vehicle railbus{definition::fiz("21xm_v1/214ma").set("UCList", "CtrlValStep", 0.05), 0.0, "test", 1};
REQUIRE(railbus->UniCtrlValStep == doctest::Approx(0.05));
get_ready(railbus, line);
// a tap on the raising position: one step at once, kept by the holding one
move_to(railbus, raise);
railbus.step(line);
CHECK(railbus->eimic == doctest::Approx(0.05));
move_to(railbus, hold);
railbus.run(2.0, line);
CHECK(railbus->eimic == doctest::Approx(0.05));
// held there: after the initial delay a step each third of a second (0.15 a second), never in between
move_to(railbus, raise);
for (int i = 0; i < 310; ++i) { // 3.1 s
railbus.step(line);
CAPTURE(i);
CHECK(on_step(railbus->eimic, 0.05));
}
// the first step at once, 1 s of the initial delay, then 2.1 s of 0.15 a second (6 steps)
CHECK(railbus->eimic == doctest::Approx(0.40));
move_to(railbus, hold);
railbus.run(2.0, line);
CHECK(railbus->eimic == doctest::Approx(0.40));
// up to the full power, and not past it
move_to(railbus, raise);
railbus.run(10.0, line);
CHECK(railbus->eimic == doctest::Approx(1.0));
// down the same way: a tap is one step, holding it goes on in steps down to nothing
move_to(railbus, lower);
railbus.step(line);
CHECK(railbus->eimic == doctest::Approx(0.95));
move_to(railbus, hold);
railbus.run(1.0, line);
CHECK(railbus->eimic == doctest::Approx(0.95));
move_to(railbus, lower);
for (int i = 0; i < 800; ++i) { // 8 s
railbus.step(line);
CAPTURE(i);
CHECK(on_step(railbus->eimic, 0.05));
}
CHECK(railbus->eimic == doctest::Approx(0.0));
}
TEST_CASE("controls: the universal controller without CtrlValStep sets its power continuously, as before") {
test::track const line{0.15, 0.0};
vehicle railbus{definition::fiz("21xm_v1/214ma"), 0.0, "test", 1};
REQUIRE(railbus->UniCtrlValStep == 0.0);
get_ready(railbus, line);
// a tap moves it by 0.01, held it goes on at 0.15 a second after the initial delay
move_to(railbus, raise);
railbus.step(line);
CHECK(railbus->eimic == doctest::Approx(0.01));
railbus.run(2.0 - 0.01, line);
CHECK(railbus->eimic == doctest::Approx(0.01 + 0.15).epsilon(0.05));
}