mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 08:46:00 +01:00
Merge remote-tracking branch 'origin/master' into feat/diesel-throttle-position-marker
# Conflicts: # vehicle/Gauge.h # vehicle/Train.cpp
This commit is contained in:
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
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