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:
46
tests/unit/data/diesel_electric.json
Normal file
46
tests/unit/data/diesel_electric.json
Normal 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]
|
||||
]
|
||||
}
|
||||
}
|
||||
53
tests/unit/data/diesel_shunter.json
Normal file
53
tests/unit/data/diesel_shunter.json
Normal 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]
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
31
tests/unit/test_ai_hints.cpp
Normal file
31
tests/unit/test_ai_hints.cpp
Normal 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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
112
tests/unit/test_dimmer.cpp
Normal 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);
|
||||
}
|
||||
}
|
||||
158
tests/unit/test_door_closure.cpp
Normal file
158
tests/unit/test_door_closure.cpp
Normal 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
54
tests/unit/test_door_wings.cpp
Normal file
54
tests/unit/test_door_wings.cpp
Normal 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);
|
||||
}
|
||||
74
tests/unit/test_engine_shutdown.cpp
Normal file
74
tests/unit/test_engine_shutdown.cpp
Normal 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());
|
||||
}
|
||||
298
tests/unit/test_engine_start.cpp
Normal file
298
tests/unit/test_engine_start.cpp
Normal 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);
|
||||
}
|
||||
110
tests/unit/test_framepacer.cpp
Normal file
110
tests/unit/test_framepacer.cpp
Normal 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));
|
||||
}
|
||||
53
tests/unit/test_gauge_duplicates.cpp
Normal file
53
tests/unit/test_gauge_duplicates.cpp
Normal 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));
|
||||
}
|
||||
30
tests/unit/test_hold_coil_lever.cpp
Normal file
30
tests/unit/test_hold_coil_lever.cpp
Normal 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));
|
||||
}
|
||||
96
tests/unit/test_lights_preset_cablight.cpp
Normal file
96
tests/unit/test_lights_preset_cablight.cpp
Normal 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());
|
||||
}
|
||||
93
tests/unit/test_lights_programmer.cpp
Normal file
93
tests/unit/test_lights_programmer.cpp
Normal 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
114
tests/unit/test_linebreaker.cpp
Normal file
114
tests/unit/test_linebreaker.cpp
Normal 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);
|
||||
}
|
||||
55
tests/unit/test_oil_pump.cpp
Normal file
55
tests/unit/test_oil_pump.cpp
Normal 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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
268
tests/unit/test_test_mode.cpp
Normal file
268
tests/unit/test_test_mode.cpp
Normal 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");
|
||||
}
|
||||
}
|
||||
115
tests/unit/test_uc_steps.cpp
Normal file
115
tests/unit/test_uc_steps.cpp
Normal 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));
|
||||
}
|
||||
Reference in New Issue
Block a user