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:
2
tests/scenarios/.gitignore
vendored
Normal file
2
tests/scenarios/.gitignore
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
out/
|
||||
__pycache__/
|
||||
249
tests/scenarios/README.md
Normal file
249
tests/scenarios/README.md
Normal file
@@ -0,0 +1,249 @@
|
||||
# Scenario tests
|
||||
|
||||
End-to-end checks that run the real simulator on a scenery and look at how the run ended
|
||||
and what a vehicle did: did it start, did it keep to the speed limit, did it brake and stop,
|
||||
did it pass a signal at stop.
|
||||
|
||||
Scenery and vehicle data are not in this repo, so these run against a local game install
|
||||
only, not in CI.
|
||||
|
||||
## The simulator's test mode
|
||||
|
||||
The runner drives the simulator's test mode (eu07/maszyna#541), which works without the
|
||||
runner too and is meant for scenery authors as well:
|
||||
|
||||
```
|
||||
eu07 --test -s <scenery.scn> [--test-timeout <seconds>] [--test-wall-timeout <seconds>] [-seed <number|word>] [-ini <settings file>]
|
||||
```
|
||||
|
||||
With `--test` the simulator:
|
||||
|
||||
- needs `-s`; `-v` is ignored and every train is driven by AI (ghostview),
|
||||
- reads the settings of the game folder's `eu07.ini` and of the files given with `-ini` (in that
|
||||
order), not the player's own `eu07.ini` in `%APPDATA%\MaSzyna` (`~/.config/MaSzyna` on Linux),
|
||||
so a test runs the same for whoever runs it,
|
||||
- draws nothing: the null renderer loads the 3D models (the physics needs some of their
|
||||
data) but no textures, and the window stays hidden,
|
||||
- has no sound, no network, no python, no pause (not even one set by the scenery), and
|
||||
no crash dialog,
|
||||
- takes no input from outside: keys and mouse sent to its window, gamepad, UART (a cab
|
||||
desk), ZeroMQ and commands sent by other programs (`WM_COPYDATA`) are all ignored, and
|
||||
motion telemetry is off,
|
||||
- gives nothing to the outside either: no keyboard leds, LPT or PoKeys (`feedbackmode`), no
|
||||
messages to a multiplayer server (`multiplayer`), no program run at the end (`execonexit`),
|
||||
no console window of its own (`showsystemconsole`), no Discord presence, and the game's `imgui.ini`
|
||||
stays as it is,
|
||||
- keeps all of the above whatever the `config` block of the scenery says: the settings of the
|
||||
test mode are applied again after it,
|
||||
- runs the simulation as fast as it can in fixed steps of 0.03 s of simulation time per
|
||||
frame (three 10 ms physics steps), whatever the real time, the time speed or the machine,
|
||||
- seeds its random numbers with a fixed seed unless `-seed` or `randomseed` gives one, so two
|
||||
runs of a scenery come out the same (the physicslogs of two runs are byte for byte equal),
|
||||
- quits when the test ends, and says how it ended in the exit code and in a `test: ...`
|
||||
line on stdout and in the log. A command line it can't take, a start that fails, or an
|
||||
exception thrown by the simulator (of any type, on Linux too) ends the same way, with the
|
||||
`error` code. That line is all there is on stdout: the log goes to
|
||||
the log file only (`debuglog` doesn't print it on the console in test mode).
|
||||
|
||||
On Windows the simulator is a windowed program, which the `cmd` prompt and PowerShell don't wait
|
||||
for. In a `.bat` file `eu07 --test ... > result.txt` waits and sets `%errorlevel%`; at the prompt
|
||||
`start /wait eu07 --test ...` waits too but doesn't pass the output on. In PowerShell use
|
||||
`(Start-Process eu07 '--test ...' -Wait -PassThru -RedirectStandardOutput result.txt).ExitCode`.
|
||||
Scripts (Python's `subprocess`, bash) wait for it as for any other program.
|
||||
|
||||
A scenery reports its result to the memory cell `__test.result`, which the simulator creates
|
||||
(in every run, so a test scenery loads normally too). Write value 1 to it for a pass and 0
|
||||
for a failure, with an `UpdateValues` event; other values are ignored, and the text, if
|
||||
given, goes to the log as the reason:
|
||||
|
||||
```
|
||||
event test_pass UpdateValues 0 __test.result reached_the_stop 1 * endevent
|
||||
event test_fail UpdateValues 0 __test.result wrong_track 0 * endevent
|
||||
```
|
||||
|
||||
(`PutValues` isn't the event for it: it hands a command to a vehicle, it doesn't write a cell.)
|
||||
A good place for the pass event is `event0` of a track the train should stop on: it runs
|
||||
while a train stands there, and the length of the track is the margin of the stop.
|
||||
|
||||
The test ends with the first of these:
|
||||
|
||||
| exit code | result | when |
|
||||
| --- | --- | --- |
|
||||
| 0 | pass | `__test.result` was set to 1 and then the tested trains stood still for 1 s, so a train still moving towards a signal at stop has to stop first (with `test.no_movement_before_pass no` the pass ends the test at once). Also the standstill end with `test.pass_on_standstill yes` |
|
||||
| 10 | fail | `__test.result` was set to 0; ends at once |
|
||||
| 11 | signal passed at danger | a train went past a signal showing stop (`SetVelocity 0 0`; `SetVelocity 0 x` on automatic block, which may be passed after a stop, doesn't count); ends at once, unless `test.fail_if_stop_overran no` |
|
||||
| 12 | timeout | `test.timeout` seconds of simulation time went by (default 3600), or `test.wall_timeout` seconds of real time since the start (see below) |
|
||||
| 13 | standstill | the tested trains stood still for `test.standstill` seconds (default 300) and nothing reported a result. Trains waiting at a station or for a signal count as standing, so the limit has to be longer than such waits |
|
||||
| 14 | error | the run could not start: no `-s`, the scenery failed to load or has no vehicles, or the simulator threw |
|
||||
|
||||
A crash ends with the system's code instead (on Windows e.g. `0xC0000005`, -1073741819). The
|
||||
codes of the test mode keep clear of the ones a process gets when it goes wrong on its own: 1
|
||||
(killed with `TerminateProcess`, or a plain failure of most programs), 3 (`abort()` on Windows),
|
||||
126-127 (a shell that can't run the program) and 128 + a signal number (killed, on Linux).
|
||||
|
||||
The limits go in a `config` block of the scenery:
|
||||
|
||||
```
|
||||
config
|
||||
test.timeout 600
|
||||
test.wall_timeout 900
|
||||
test.standstill 120
|
||||
test.pass_on_standstill no
|
||||
test.fail_if_stop_overran yes
|
||||
test.no_movement_before_pass yes
|
||||
test.vehicle ep07-424
|
||||
endconfig
|
||||
```
|
||||
|
||||
| key | default | meaning |
|
||||
| --- | --- | --- |
|
||||
| `test.timeout` | 3600 | seconds of simulation time before the test ends as `timeout`; 0 = never |
|
||||
| `test.wall_timeout` | `test.timeout` + 600 | seconds of real time since the start before the test ends as `timeout`; 0 = never |
|
||||
| `test.standstill` | 300 | seconds with the tested trains still and no result before the test ends as `standstill`; 0 = never |
|
||||
| `test.pass_on_standstill` | no | the standstill end passes the test instead |
|
||||
| `test.fail_if_stop_overran` | yes | a signal passed at danger ends the test; with `no` it's only logged |
|
||||
| `test.no_movement_before_pass` | yes | a pass waits until the tested trains stand still; with `no` it ends the test at once |
|
||||
| `test.vehicle` | none | a vehicle of a train under test, by its name in the scenery (once for each train under test). The tested trains are the consists of these vehicles as they are at the moment (a train the tested one couples to joins it), and only they count for the pass and the standstill: other trains, AI traffic, may run on. A name the scenery doesn't have ends the test with `error`. Not given, every vehicle of the scenery counts. A signal passed at danger counts for every train either way |
|
||||
|
||||
`--test-timeout` and `--test-wall-timeout` on the command line win over `test.timeout` and
|
||||
`test.wall_timeout` of the scenery and the settings files.
|
||||
|
||||
`test.wall_timeout` is a watchdog in real time, for a run that hangs or crawls: when the
|
||||
simulator still runs that many seconds after its start, loading included, it says `test: timeout`
|
||||
and quits with the timeout code, whatever it is doing at the moment, with no dialog. Not given,
|
||||
it is `test.timeout` + 600 s: ten minutes for the loading, and a simulation that runs at least as
|
||||
fast as real time is never cut short by it. With `test.timeout 0` there is no watchdog unless
|
||||
`test.wall_timeout` is given; `test.wall_timeout 0` turns it off. A test that has ended but whose
|
||||
simulator doesn't close is ended by the watchdog too, with its own result.
|
||||
|
||||
A signal is passed at danger when the head of a train goes past a signal which its driver
|
||||
has in its speed table, showing stop. So it's the driver's view that counts: a train without
|
||||
a driver isn't watched, and neither is a signal the driver never scanned (a train placed at
|
||||
100 km/h 150 m before a signal at stop got past it before its AI first looked ahead; at
|
||||
60 km/h it was caught). Outside the test mode the same is written to the log, nothing more.
|
||||
|
||||
## Running
|
||||
|
||||
```
|
||||
python tests/scenarios/run.py --game-dir "C:/Steam/steamapps/common/MaSzyna" -j 4
|
||||
```
|
||||
|
||||
Python 3.10+, no extra packages. Options:
|
||||
|
||||
- `EU07_GAME_DIR` can replace `--game-dir`.
|
||||
- `--exe path/to/eu07.exe` picks the build to test; the default is the newest
|
||||
`cmake-build-*/bin/Release/eu07*.exe`. The build needs the `--test` and `-ini` command
|
||||
line options.
|
||||
- name one or more cases to run only those, e.g. `run.py ... eu07_td_timetable`.
|
||||
- `-j N` runs N cases at once. Each case prints its results when it is done. All 17 cases
|
||||
take about 30 s with `-j 4`, loading included.
|
||||
- `--watch` runs a case the old way, in a visible window in real time (or faster with
|
||||
`--timespeed N`), closed after the case's `duration`; the exit code isn't checked then. For
|
||||
watching what a case does.
|
||||
|
||||
Exit code is 0 when every case passed. Logs of each run (`log.txt`, `errors.txt`,
|
||||
`stdout.txt`, the physicslogs of the vehicle and of other trains of the case) are moved to
|
||||
`tests/scenarios/out/<case>/`.
|
||||
|
||||
## How it works
|
||||
|
||||
For each case the runner:
|
||||
|
||||
1. writes `scenery/autotest_<case>.scn` into the game dir: the base scenery with its own
|
||||
trainsets removed, the start time changed if the case says so, the case's track events
|
||||
added, and the case's `.scn` fragment added: its trainsets after `FirstInit`, everything
|
||||
else (the case's `test_config`, event launchers standing in for keys the scenery expects a
|
||||
player to press, extra events) before it,
|
||||
2. starts the simulator with `--test -s autotest_<case>.scn -ini out/<case>/autotest.ini
|
||||
--test-wall-timeout <timeout>`, plus `--test-timeout <duration>` when the case gives a
|
||||
`duration`; the extra ini turns on
|
||||
`physicslog` and writes the logs to `logs/log (autotest_<case>) <date>.txt` rather than the
|
||||
shared `log.txt` (`multiplelogs`),
|
||||
3. waits until the simulator quits by itself. It gives up early when the log reports
|
||||
`Bad vehicle` / `Bad trainset`, or when the scenario has loaded and no physicslog appeared.
|
||||
After the case's `timeout` of wall-clock time the simulator ends itself with the timeout code;
|
||||
one that doesn't is killed 30 s later,
|
||||
4. compares the result from the exit code with the case's `expect`, then runs the checks on
|
||||
the physicslog.
|
||||
|
||||
The lead vehicle is named `autotest_<case>`, so every case has its own physicslog and log
|
||||
files and cases can run in parallel. The `autotest_*` sceneries (and the simulator's `.sbt`
|
||||
geometry cache of them) stay in the game's `scenery/` dir; the cache is dropped when the base
|
||||
scenery is newer, and after a run cut short (`wall_timeout`, `error`, a crash, or killed by run.py),
|
||||
which could have been writing it.
|
||||
|
||||
## Writing a case
|
||||
|
||||
`cases/<name>.json`:
|
||||
|
||||
| key | meaning |
|
||||
| --- | --- |
|
||||
| `base_scenery` | scenery file in the game's `scenery/` dir |
|
||||
| `strip_trainsets` | drop the base scenery's trainsets (default `true`) |
|
||||
| `time` | replace the scenery start time, `HH:MM` |
|
||||
| `track_friction` | set the friction of every track of the base scenery (default in the sceneries is 0.15), e.g. for slippery rail |
|
||||
| `track_events` | lines added to tracks of the base scenery, by track name, e.g. `{ "tor1k": "event0 test_pass" }`; only tracks in the scenery file itself, not in its includes |
|
||||
| `test_config` | lines of a `config` block added to the scenery, e.g. `["test.timeout 90"]`; the block always has `test.vehicle` with the case's lead vehicle, so only its train counts for the pass and the standstill |
|
||||
| `fragment` | `.scn` file in `cases/` added to the scenery: trainsets after `FirstInit` (before it they derail on unlinked track), the rest before it (launchers read after it never fire) |
|
||||
| `vars` | values for `{{name}}` in the fragment; a list becomes one line per item |
|
||||
| `expect` | the result the test mode should end with: `pass`, `fail`, `signal_passed_at_danger`, `timeout`, `standstill` or `error`, or `wall_timeout` for the timeout of the real time watchdog (the timeout code with a verdict saying it was the real time; a case expecting `timeout` fails on it). Default `timeout` for a case with `duration`, else `pass` |
|
||||
| `duration` | seconds of simulation to record: the test timeout of the run (`--test-timeout`) |
|
||||
| `timeout` | wall-clock seconds before giving up, loading included: the simulator's `--test-wall-timeout` (default 600) |
|
||||
| `fail_on_errors` | fail when `errors.txt` is not empty (default `false`) |
|
||||
| `checks` | list of checks, below |
|
||||
|
||||
`{{vehicle}}` is always set, also inside `vars` values: the node name of the lead vehicle,
|
||||
the one whose physicslog is checked, and the train under test (`test.vehicle`). Other vehicles
|
||||
of the consist take names made from it, e.g. `{{vehicle}}_s`; another train with a driver is named
|
||||
`<something>_{{vehicle}}`, so its physicslog is moved out of the game dir too. The td.scn cases share two fragments, `td_timetable.scn` (route set,
|
||||
train runs to Przystanek) and `td_red_signal.scn` (no route, exit signal at stop), and differ
|
||||
only in `vars.consist`. Przystanek is a technical stop in that timetable (`pt`), where the AI
|
||||
doesn't wait for the departure time: it sets off as soon as it counts the train as standing at
|
||||
the W4, which is below 1 km/h, so the train stands there for a few seconds at most, or doesn't
|
||||
quite stop (since the AI braking of #264 the SN61 turns back at 0.4 km/h). The
|
||||
timetable cases therefore check that the train comes down to 1 km/h, with no hold, 1380-1420 m
|
||||
from the start (each of the seven trains stops at 1397-1401 m). `td_red_signal_moving.scn` is the red signal one with the train
|
||||
starting at `vars.velocity` km/h; with `track_friction` 0.03 it locks the wheels when braking
|
||||
and slides past the signal, so those cases set `test.fail_if_stop_overran no`.
|
||||
`td_red_signal_pass.scn` adds the `test_pass` event, which `test_mode_pass` puts as `event0`
|
||||
on `tor1k`, the track in front of the signal.
|
||||
|
||||
The `test_mode_*` cases show the ends of the test mode: `test_mode_pass` (exit 0, the pass
|
||||
event), `test_mode_signal_passed_at_danger` (exit 11), `test_mode_timeout` (exit 12, from
|
||||
`test.timeout`), `test_mode_standstill` (exit 13, from `test.standstill`) and
|
||||
`test_mode_wall_timeout` (exit 12 from the real time watchdog, which ends it while it loads).
|
||||
`test_mode_standstill_traffic` (fragment `td_traffic.scn`) has a train under test standing on
|
||||
track 2 of Stacja1 and AI traffic, `traffic_{{vehicle}}`, leaving track 1 on the timetable: the
|
||||
standstill of 100 s ends the test although the traffic runs on (counting every vehicle, it runs
|
||||
into the test timeout).
|
||||
`test_mode_pass_while_moving` reports the pass from `event2` of `tor1k` (the direction the train runs), as the train runs onto
|
||||
it, with `test.no_movement_before_pass no`, so the test ends with the train still moving.
|
||||
|
||||
Checks (speeds in km/h, times in seconds of physicslog time, distances in metres). Most use
|
||||
the physicslog Velocity column, which is the wheel speed: it stays at 0 while the wheels are
|
||||
locked in a skid. The ones marked *vehicle speed* use the vehicle speed column at the end of
|
||||
the row instead, logged by builds from this branch on.
|
||||
|
||||
- `starts` `min_speed`, `within`: reaches `min_speed` within `within` seconds.
|
||||
- `max_speed` `limit`, `tolerance`: never goes faster than `limit + tolerance`.
|
||||
- `brakes` `min_pressure`: after moving off, brake cylinder pressure reaches `min_pressure` bar
|
||||
(physicslog pressures are in bar whatever its header says; the brake pipe runs at 5.0).
|
||||
- `stops` `moving_speed`, `stop_speed`, `hold`, optional `min_distance`, `max_distance`: after
|
||||
reaching `moving_speed`, stays at or below `stop_speed` for `hold` seconds; with the distances,
|
||||
that stop has to be between them (metres travelled, as in `distance`).
|
||||
- `stays_stopped` `moving_speed`, `stop_speed`: after moving off and stopping, never goes
|
||||
above `stop_speed` again.
|
||||
- `distance` `min`, `max`: total distance travelled. The physicslog has no position, so the
|
||||
distance comes from integrating the speed; on td.scn every vehicle's first stop after
|
||||
Stacja1 came out at 1400 m (+-4), and the red signal stop at 140 m.
|
||||
- `slips` `within`: the lead vehicle's wheels slip or lock at some point (within `within`
|
||||
seconds if given), so a slippery rail case does what it's meant to.
|
||||
- `slip_clears` `moving_speed`, `stop_speed`, `within` (*vehicle speed*): once stopped after
|
||||
moving off, the wheels stop slipping within `within` seconds.
|
||||
- `holds_still` `moving_speed`, `stop_speed`, `max_distance` (*vehicle speed*): once stopped
|
||||
after moving off, moves no more than `max_distance` metres, e.g. no creeping on locked wheels.
|
||||
- `ends_moving` `min_speed`: the last row of the physicslog is at `min_speed` or faster, e.g.
|
||||
the test ended without waiting for the train to stop.
|
||||
|
||||
New check types go in `CHECKS` in `run.py`; each gets the physicslog rows and the check's
|
||||
parameters and returns `(passed, detail)`.
|
||||
21
tests/scenarios/cases/en57_td_timetable.json
Normal file
21
tests/scenarios/cases/en57_td_timetable.json
Normal file
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"description": "EN57 EMU (three cars) on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": [
|
||||
"node -1 0 {{vehicle}} dynamic pkp\\en57_v2 EN57-1000ra EN57RA_GSO_WKM1_KM_NS_N 0 headdriver 255 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_s dynamic pkp\\en57_v2 EN57-1000s EN57S_WKM1_KM_NS_S 0 nobody 255 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_rb dynamic pkp\\en57_v2 EN57-1000rb EN57RB_GSO_WKM1_KM_NS 0 nobody 0 0 enddynamic"
|
||||
]
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
17
tests/scenarios/cases/ep09_td_timetable.json
Normal file
17
tests/scenarios/cases/ep09_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "EP09 on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\ep09_v1 104e-005 104e_3 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
17
tests/scenarios/cases/et22_td_timetable.json
Normal file
17
tests/scenarios/cases/et22_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "ET22 on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\et22_v3 201E-1150 201E 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
39
tests/scenarios/cases/eu07_slippery_push_red_signal.json
Normal file
39
tests/scenarios/cases/eu07_slippery_push_red_signal.json
Normal file
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"description": "EU07 pushing three coaches on td.scn with slippery rail and no route set, starting at 30 km/h: brakes for the exit signal at stop and skids. Pushed by the train it doesn't roll back at the stop, so it used to stay skidding on locked wheels with the brakes capped by the sliding adhesion and creep (eu07/maszyna#479).",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"track_friction": 0.03,
|
||||
"fragment": "td_red_signal_moving.scn",
|
||||
"test_config": [
|
||||
"test.fail_if_stop_overran no"
|
||||
],
|
||||
"vars": {
|
||||
"velocity": "30",
|
||||
"consist": [
|
||||
"node -1 0 {{vehicle}}_w1 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608068-6 BDHPUMN_TAPICERKA_1 0 nobody 115 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_w2 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608011-6 BDHPUMN_NG_1 0 nobody 115 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_w3 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608068-6 BDHPUMN_TAPICERKA_1 0 nobody 115 0 enddynamic",
|
||||
"node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
]
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 900,
|
||||
"checks": [
|
||||
{
|
||||
"type": "slips",
|
||||
"within": 60
|
||||
},
|
||||
{
|
||||
"type": "slip_clears",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.05,
|
||||
"within": 5
|
||||
},
|
||||
{
|
||||
"type": "holds_still",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.05,
|
||||
"max_distance": 0.01
|
||||
}
|
||||
]
|
||||
}
|
||||
39
tests/scenarios/cases/eu07_slippery_red_signal.json
Normal file
39
tests/scenarios/cases/eu07_slippery_red_signal.json
Normal file
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"description": "EU07 with three coaches on td.scn with slippery rail and no route set, starting at 30 km/h: brakes for the exit signal at stop and skids, then the skid ends and the train holds still.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"track_friction": 0.03,
|
||||
"fragment": "td_red_signal_moving.scn",
|
||||
"test_config": [
|
||||
"test.fail_if_stop_overran no"
|
||||
],
|
||||
"vars": {
|
||||
"velocity": "30",
|
||||
"consist": [
|
||||
"node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_w1 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608068-6 BDHPUMN_TAPICERKA_1 0 nobody 115 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_w2 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608011-6 BDHPUMN_NG_1 0 nobody 115 0 enddynamic",
|
||||
"node -1 0 {{vehicle}}_w3 dynamic pkp\\bdhpumn_v3 bdhpumn_50512608068-6 BDHPUMN_TAPICERKA_1 0 nobody 115 0 enddynamic"
|
||||
]
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 900,
|
||||
"checks": [
|
||||
{
|
||||
"type": "slips",
|
||||
"within": 60
|
||||
},
|
||||
{
|
||||
"type": "slip_clears",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.05,
|
||||
"within": 5
|
||||
},
|
||||
{
|
||||
"type": "holds_still",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.05,
|
||||
"max_distance": 0.01
|
||||
}
|
||||
]
|
||||
}
|
||||
18
tests/scenarios/cases/eu07_td_red_signal.json
Normal file
18
tests/scenarios/cases/eu07_td_red_signal.json
Normal file
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"description": "EU07 on td.scn with no route set: pulls off, stops before the exit signal stacja1_j at stop, and stays there.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 5, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 40 },
|
||||
{ "type": "stops", "moving_speed": 5, "stop_speed": 0.5, "hold": 5 },
|
||||
{ "type": "stays_stopped", "moving_speed": 5, "stop_speed": 0.5 },
|
||||
{ "type": "distance", "max": 150 }
|
||||
]
|
||||
}
|
||||
17
tests/scenarios/cases/eu07_td_timetable.json
Normal file
17
tests/scenarios/cases/eu07_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "EU07 on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
17
tests/scenarios/cases/sm42_td_timetable.json
Normal file
17
tests/scenarios/cases/sm42_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "SM42 diesel shunter on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\sm42_v1 6D-468 6D 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
17
tests/scenarios/cases/sn61_td_timetable.json
Normal file
17
tests/scenarios/cases/sn61_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "SN61 diesel railcar on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\sn61_v2 SN61-13 SN61_v1 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
6
tests/scenarios/cases/td_red_signal.scn
Normal file
6
tests/scenarios/cases/td_red_signal.scn
Normal file
@@ -0,0 +1,6 @@
|
||||
// added by tests/scenarios/run.py to td.scn, whose own trainsets were removed.
|
||||
// same start as td_timetable.scn, but nobody sets the route: the exit signal stacja1_j,
|
||||
// about 150 m ahead of the train, stays at stop.
|
||||
trainset td/rozklad tdo_n1734 0.0 0.1
|
||||
{{consist}}
|
||||
endtrainset
|
||||
6
tests/scenarios/cases/td_red_signal_moving.scn
Normal file
6
tests/scenarios/cases/td_red_signal_moving.scn
Normal file
@@ -0,0 +1,6 @@
|
||||
// added by tests/scenarios/run.py to td.scn, whose own trainsets were removed.
|
||||
// like td_red_signal.scn (no route, the exit signal stacja1_j about 150 m ahead stays at stop),
|
||||
// but the train starts already moving at {{velocity}} km/h, so it has to brake right away.
|
||||
trainset td/rozklad tdo_n1734 0.0 {{velocity}}
|
||||
{{consist}}
|
||||
endtrainset
|
||||
8
tests/scenarios/cases/td_red_signal_pass.scn
Normal file
8
tests/scenarios/cases/td_red_signal_pass.scn
Normal file
@@ -0,0 +1,8 @@
|
||||
// added by tests/scenarios/run.py to td.scn, whose own trainsets were removed.
|
||||
// like td_red_signal.scn (no route, the exit signal stacja1_j about 150 m ahead stays at stop),
|
||||
// with the test mode's pass event: the case puts it as event0 on tor1k, the track in front of
|
||||
// the signal, so it runs once the train stands there. the test passes when every vehicle stopped.
|
||||
event test_pass UpdateValues 0 __test.result stopped_before_stacja1_j 1 * endevent
|
||||
trainset td/rozklad tdo_n1734 0.0 0.1
|
||||
{{consist}}
|
||||
endtrainset
|
||||
12
tests/scenarios/cases/td_timetable.scn
Normal file
12
tests/scenarios/cases/td_timetable.scn
Normal file
@@ -0,0 +1,12 @@
|
||||
// added by tests/scenarios/run.py to td.scn, whose own trainsets were removed:
|
||||
// the trainset goes after FirstInit, the launcher before it.
|
||||
// the case's consist stands where td.scn keeps its timetable train (track 1 of Stacja1)
|
||||
// and gets the same timetable: Stacja1 10:35 -> Przystanek -> Stacja2.
|
||||
trainset td/rozklad tdo_n1734 0.0 0.1
|
||||
{{consist}}
|
||||
endtrainset
|
||||
|
||||
// td.scn sets routes from the keyboard (shift+1..4 run events keyctrl01..04). keyctrl04 is the
|
||||
// way out of track 1: switch zwr02 and the exit signal stacja1_j at 40.
|
||||
// a launcher with a positive time fires once at that hour (HHMM), radius -1 means anywhere.
|
||||
node -1 0 autotest_route eventlauncher 0 0 0 -1 none 1034 keyctrl04 end
|
||||
13
tests/scenarios/cases/td_traffic.scn
Normal file
13
tests/scenarios/cases/td_traffic.scn
Normal file
@@ -0,0 +1,13 @@
|
||||
// added by tests/scenarios/run.py to td.scn, whose own trainsets were removed: two trains at Stacja1.
|
||||
// the train under test (test.vehicle) stands on track 2, where its driver has nothing to do; the other one,
|
||||
// AI traffic, has the td/rozklad timetable on track 1 and leaves for Przystanek at 10:35. the standstill of
|
||||
// the test waits for the train under test only, so the traffic running on doesn't hold it up.
|
||||
trainset none tor2k 30.0 0.0
|
||||
node -1 0 {{vehicle}} dynamic pkp\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic
|
||||
endtrainset
|
||||
trainset td/rozklad tdo_n1734 0.0 0.1
|
||||
node -1 0 traffic_{{vehicle}} dynamic pkp\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic
|
||||
endtrainset
|
||||
|
||||
// the way out of track 1 for the traffic, see td_timetable.scn
|
||||
node -1 0 autotest_route eventlauncher 0 0 0 -1 none 1034 keyctrl04 end
|
||||
31
tests/scenarios/cases/test_mode_pass.json
Normal file
31
tests/scenarios/cases/test_mode_pass.json
Normal file
@@ -0,0 +1,31 @@
|
||||
{
|
||||
"description": "Test mode, pass: EU07 on td.scn with no route set stops before the exit signal stacja1_j; event0 of the track there reports the pass, and the test ends as passed once the train stands.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal_pass.scn",
|
||||
"track_events": {
|
||||
"tor1k": "event0 test_pass"
|
||||
},
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "pass",
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "starts",
|
||||
"min_speed": 5,
|
||||
"within": 150
|
||||
},
|
||||
{
|
||||
"type": "stops",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.5,
|
||||
"hold": 0.5
|
||||
},
|
||||
{
|
||||
"type": "distance",
|
||||
"max": 150
|
||||
}
|
||||
]
|
||||
}
|
||||
28
tests/scenarios/cases/test_mode_pass_while_moving.json
Normal file
28
tests/scenarios/cases/test_mode_pass_while_moving.json
Normal file
@@ -0,0 +1,28 @@
|
||||
{
|
||||
"description": "Test mode, pass without waiting for a stop: like test_mode_pass, but event2 of the track in front of the exit signal reports the pass as the train runs onto it, and with test.no_movement_before_pass no the test ends at once, the train still moving.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal_pass.scn",
|
||||
"track_events": {
|
||||
"tor1k": "event2 test_pass"
|
||||
},
|
||||
"test_config": [
|
||||
"test.no_movement_before_pass no"
|
||||
],
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "pass",
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "starts",
|
||||
"min_speed": 5,
|
||||
"within": 150
|
||||
},
|
||||
{
|
||||
"type": "ends_moving",
|
||||
"min_speed": 3
|
||||
}
|
||||
]
|
||||
}
|
||||
22
tests/scenarios/cases/test_mode_signal_passed_at_danger.json
Normal file
22
tests/scenarios/cases/test_mode_signal_passed_at_danger.json
Normal file
@@ -0,0 +1,22 @@
|
||||
{
|
||||
"description": "Test mode, signal passed at danger: EU07 on td.scn with no route set starts at 60 km/h about 150 m before the exit signal stacja1_j at stop. Its AI driver is still preparing the engine and doesn't brake, and the run ends when the train passes the signal.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal_moving.scn",
|
||||
"vars": {
|
||||
"velocity": "60",
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "signal_passed_at_danger",
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "max_speed",
|
||||
"limit": 61
|
||||
},
|
||||
{
|
||||
"type": "distance",
|
||||
"min": 140
|
||||
}
|
||||
]
|
||||
}
|
||||
26
tests/scenarios/cases/test_mode_standstill.json
Normal file
26
tests/scenarios/cases/test_mode_standstill.json
Normal file
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"description": "Test mode, standstill: EU07 on td.scn with no route set stops before the exit signal stacja1_j at stop and stays; nothing reports a result, so the test ends once the train under test stood still for test.standstill 120 seconds (the train waits about 70 s before it pulls off, so less would end it before the start).",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal.scn",
|
||||
"test_config": [
|
||||
"test.standstill 120"
|
||||
],
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "standstill",
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "stops",
|
||||
"moving_speed": 5,
|
||||
"stop_speed": 0.5,
|
||||
"hold": 5
|
||||
},
|
||||
{
|
||||
"type": "distance",
|
||||
"max": 150
|
||||
}
|
||||
]
|
||||
}
|
||||
18
tests/scenarios/cases/test_mode_standstill_traffic.json
Normal file
18
tests/scenarios/cases/test_mode_standstill_traffic.json
Normal file
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"description": "Test mode, standstill with traffic: an EU07 stands on track 2 of Stacja1 on td.scn while another EU07, AI traffic, leaves track 1 on the td/rozklad timetable at 10:35 and runs on. Only the train under test (test.vehicle, the case's vehicle) counts, so the test ends on test.standstill 100 although the traffic is moving; counting every vehicle, it would run into the 300 s test timeout.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_traffic.scn",
|
||||
"test_config": [
|
||||
"test.standstill 100"
|
||||
],
|
||||
"expect": "standstill",
|
||||
"duration": 300,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "max_speed",
|
||||
"limit": 0.5
|
||||
}
|
||||
]
|
||||
}
|
||||
21
tests/scenarios/cases/test_mode_timeout.json
Normal file
21
tests/scenarios/cases/test_mode_timeout.json
Normal file
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"description": "Test mode, timeout: EU07 on td.scn with no route set pulls off towards the exit signal stacja1_j at stop; nothing reports a result and test.timeout 90 from the scenery's config block runs out first.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal.scn",
|
||||
"test_config": [
|
||||
"test.timeout 90"
|
||||
],
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "timeout",
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{
|
||||
"type": "starts",
|
||||
"min_speed": 5,
|
||||
"within": 90
|
||||
}
|
||||
]
|
||||
}
|
||||
11
tests/scenarios/cases/test_mode_wall_timeout.json
Normal file
11
tests/scenarios/cases/test_mode_wall_timeout.json
Normal file
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"description": "Test mode, real time limit: EU07 on td.scn, with a limit of 2 s of real time (the case's timeout, which the runner passes as --test-wall-timeout). The scenery takes longer to load, so the simulator's watchdog ends the run while it loads, with the timeout code and a verdict saying it was the real time.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_red_signal.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\4e_v1 4e-004 4e 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"expect": "wall_timeout",
|
||||
"timeout": 2
|
||||
}
|
||||
17
tests/scenarios/cases/vectron_td_timetable.json
Normal file
17
tests/scenarios/cases/vectron_td_timetable.json
Normal file
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"description": "Vectron 1293-107 on td.scn, AI driver on the td/rozklad timetable: starts from Stacja1, keeps to the speed limit, brakes to a stop at Przystanek.",
|
||||
"base_scenery": "td.scn",
|
||||
"time": "10:34",
|
||||
"fragment": "td_timetable.scn",
|
||||
"vars": {
|
||||
"consist": "node -1 0 {{vehicle}} dynamic pkp\\vectron_v1 1293-107 wariant_7w 0 headdriver 0 0 enddynamic"
|
||||
},
|
||||
"duration": 240,
|
||||
"timeout": 600,
|
||||
"checks": [
|
||||
{ "type": "starts", "min_speed": 20, "within": 150 },
|
||||
{ "type": "max_speed", "limit": 90, "tolerance": 3 },
|
||||
{ "type": "brakes", "min_pressure": 0.5 },
|
||||
{ "type": "stops", "moving_speed": 20, "stop_speed": 1.0, "hold": 0, "min_distance": 1380, "max_distance": 1420 }
|
||||
]
|
||||
}
|
||||
640
tests/scenarios/run.py
Normal file
640
tests/scenarios/run.py
Normal file
@@ -0,0 +1,640 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Scenario tests: run the real simulator on a scenery and check what a vehicle did.
|
||||
|
||||
A case (cases/<name>.json) names a base scenery from the game install, a fragment
|
||||
added to it (usually a trainset with an AI driver), the result the simulator's test
|
||||
mode should end with, and checks on the vehicle's physics log. The runner:
|
||||
|
||||
1. builds scenery/autotest_<case>.scn in the game dir: the base scenery with its own
|
||||
trainsets removed, optionally a different start time, and the case fragment added,
|
||||
2. starts eu07 in test mode (--test: every train driven by AI, nothing drawn, fixed
|
||||
time steps as fast as it can) with that scenery and an extra settings file (-ini)
|
||||
that turns on physicslog,
|
||||
3. waits until the simulator quits by itself and reads the test result from its exit
|
||||
code: pass, fail, signal passed at danger, timeout (after `duration` seconds of
|
||||
simulation, if the case gives one), standstill or error,
|
||||
4. compares the result with the one the case expects, evaluates the checks on the
|
||||
physicslog and prints PASS/FAIL per check.
|
||||
|
||||
Scenery and vehicle data are not part of this repo, so this runs against a local game
|
||||
install only (--game-dir or EU07_GAME_DIR), not in CI. See README.md.
|
||||
|
||||
Usage:
|
||||
python tests/scenarios/run.py --game-dir "E:/.../MaSzyna" -j 4 # all cases
|
||||
python tests/scenarios/run.py --game-dir ... eu07_td_timetable # chosen cases
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
REPO = HERE.parents[1]
|
||||
CASES_DIR = HERE / "cases"
|
||||
OUT_DIR = HERE / "out"
|
||||
|
||||
# physicslog columns, see TController::PhysicsLog() in vehicle/Driver.cpp.
|
||||
# Velocity is in km/h and pressures in bar, despite the header saying m/s and MPa.
|
||||
COL_TIME = 0
|
||||
COL_VELOCITY = 1 # wheel speed: stays at 0 while the wheels are locked in a skid
|
||||
COL_BRAKE_PRESS = 8
|
||||
COL_COMMAND = 16 # text, read as None
|
||||
COL_WHEELSLIP = 20
|
||||
COL_VEHICLE_VELOCITY = 25 # signed vehicle speed, km/h; only in builds which log it
|
||||
|
||||
# exit codes of the simulator's test mode (eu07 --test), see simulation/simulationtestrules.h
|
||||
EXIT_RESULTS = {
|
||||
0: "pass",
|
||||
10: "fail",
|
||||
11: "signal_passed_at_danger",
|
||||
12: "timeout",
|
||||
13: "standstill",
|
||||
14: "error",
|
||||
}
|
||||
# the timeout of the simulator's real time watchdog (test.wall_timeout) has the timeout code too; told
|
||||
# apart by its verdict, so a run that hung doesn't pass a case that expects the simulation time to run out
|
||||
WALL_TIMEOUT = "wall_timeout"
|
||||
RESULTS = (*EXIT_RESULTS.values(), WALL_TIMEOUT)
|
||||
|
||||
# settings layered over the game's eu07.ini for a test run (test mode doesn't read the player's own
|
||||
# in %APPDATA%); the window ones only matter
|
||||
# with --watch, test mode keeps its window hidden and turns the sound off by itself
|
||||
TEST_INI = """\
|
||||
fullscreen no
|
||||
fullscreenwindowed no
|
||||
width 1280
|
||||
height 720
|
||||
inactivepause no
|
||||
soundenabled no
|
||||
physicslog yes
|
||||
multiplelogs yes
|
||||
timespeed {timespeed}
|
||||
"""
|
||||
# multiplelogs: log and errors go to logs/log (<scenery>) <date>.txt instead of the shared
|
||||
# log.txt, so runs of different cases can go in parallel
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- scenery
|
||||
|
||||
|
||||
def split_trainsets(text: str) -> tuple[str, str]:
|
||||
"""Splits text into (everything else, the trainset ... endtrainset blocks)."""
|
||||
rest, trainsets = [], []
|
||||
inside = False
|
||||
for line in text.splitlines(keepends=True):
|
||||
tokens = line.split("//", 1)[0].split()
|
||||
if not inside and tokens and tokens[0].lower() == "trainset":
|
||||
inside = True
|
||||
if inside:
|
||||
trainsets.append(line)
|
||||
if any(t.lower() == "endtrainset" for t in tokens):
|
||||
inside = False
|
||||
continue
|
||||
rest.append(line)
|
||||
return "".join(rest), "".join(trainsets)
|
||||
|
||||
|
||||
def set_start_time(text: str, hhmm: str) -> str:
|
||||
return re.sub(r"(?im)^(\s*time\s+)\d{1,2}:\d{2}", lambda m: m.group(1) + hhmm, text, count=1)
|
||||
|
||||
|
||||
def add_track_events(text: str, events: dict) -> str:
|
||||
"""Adds lines (e.g. "event0 test_pass") to tracks named in events, before their endtrack."""
|
||||
for track, lines in events.items():
|
||||
lines = [lines] if isinstance(lines, str) else lines
|
||||
m = re.search(rf"(?im)^\s*node\s+\S+\s+\S+\s+{re.escape(track)}\s+track\b.*?^(\s*endtrack\b)", text, re.S)
|
||||
if not m:
|
||||
sys.exit(f"track_events: no track {track} in the base scenery itself (not in its includes)")
|
||||
text = text[: m.start(1)] + "".join(line + "\n" for line in lines) + text[m.start(1):]
|
||||
return text
|
||||
|
||||
|
||||
def set_track_friction(text: str, friction: float) -> str:
|
||||
"""Sets the friction of every track: node <range> <range> <name> track <type> <length> <gauge> <friction> ..."""
|
||||
return re.sub(r"(?im)^(\s*node\s+\S+\s+\S+\s+\S+\s+track\s+\S+\s+\S+\s+\S+\s+)[-\d.]+",
|
||||
lambda m: m.group(1) + f"{friction}", text)
|
||||
|
||||
|
||||
def fill_vars(fragment: str, values: dict, keep=frozenset()) -> str:
|
||||
"""Replaces {{name}} with the case's value; a list value becomes one line per item."""
|
||||
def value(m):
|
||||
if m.group(1) in keep:
|
||||
return m.group(0)
|
||||
v = values.get(m.group(1))
|
||||
if v is None:
|
||||
sys.exit(f"fragment uses {{{{{m.group(1)}}}}} but the case sets no such var")
|
||||
return "\n".join(v) if isinstance(v, list) else str(v)
|
||||
return re.sub(r"\{\{(\w+)\}\}", value, fragment)
|
||||
|
||||
|
||||
def scenery_cache(game_dir: Path, case_name: str) -> Path:
|
||||
"""The simulator's geometry cache of the case scenery."""
|
||||
return game_dir / "scenery" / f"autotest_{case_name}.sbt"
|
||||
|
||||
|
||||
def build_scenery(case: dict, game_dir: Path, case_name: str, vehicle: str) -> str:
|
||||
"""Writes the case scenery into the game's scenery dir and returns its file name."""
|
||||
scenery_dir = game_dir / "scenery"
|
||||
# sceneries are cp1250; latin-1 round-trips every byte, so nothing gets mangled
|
||||
text = (scenery_dir / case["base_scenery"]).read_bytes().decode("latin-1")
|
||||
if case.get("strip_trainsets", True):
|
||||
text, _ = split_trainsets(text)
|
||||
if "time" in case:
|
||||
text = set_start_time(text, case["time"])
|
||||
if "track_friction" in case:
|
||||
text = set_track_friction(text, case["track_friction"])
|
||||
if "track_events" in case:
|
||||
text = add_track_events(text, case["track_events"])
|
||||
fragment = (CASES_DIR / case["fragment"]).read_bytes().decode("latin-1")
|
||||
# vars first: {{vehicle}} inside a var's value gets filled in the second pass
|
||||
fragment = fill_vars(fragment, case.get("vars", {}), keep={"vehicle"})
|
||||
fragment = fill_vars(fragment, {"vehicle": vehicle})
|
||||
# FirstInit binds event launchers to their events and links the tracks. so launchers and
|
||||
# events of the case go in before it (read after it they never fire), trainsets after it
|
||||
# (placed before it they stand on unlinked track and derail at once)
|
||||
before, trainsets = split_trainsets(fragment)
|
||||
# settings of the test mode, read like any other config block: the case's vehicle is the train under test,
|
||||
# whose consist the pass and the standstill wait for, and the case's own (test.timeout and so on)
|
||||
config = [f"test.vehicle {vehicle}", *case.get("test_config", [])]
|
||||
before = "config\n" + "".join(line + "\n" for line in config) + "endconfig\n" + before
|
||||
header = f"\n// ---- autotest: {case_name} ----\n"
|
||||
firstinit = re.search(r"(?im)^\s*firstinit\b", text)
|
||||
if firstinit:
|
||||
text = text[: firstinit.start()] + header + before + "\n" + text[firstinit.start():]
|
||||
else:
|
||||
text += header + before + "\n"
|
||||
text += header + trainsets + "\n"
|
||||
name = f"autotest_{case_name}.scn"
|
||||
(scenery_dir / name).write_bytes(text.encode("latin-1"))
|
||||
# the simulator caches the scenery's static geometry in <name>.sbt and reads it instead of
|
||||
# the terrain in the .scn (tracks, events and trainsets always come from the .scn), so
|
||||
# drop the cache once the base scenery has changed
|
||||
cache = scenery_cache(game_dir, case_name)
|
||||
if cache.exists() and cache.stat().st_mtime < (scenery_dir / case["base_scenery"]).stat().st_mtime:
|
||||
cache.unlink()
|
||||
return name
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- run
|
||||
|
||||
|
||||
def read_physicslog(path: Path) -> list[list[float]]:
|
||||
"""Returns rows of columns, None for the text ones; skips the header and partial lines."""
|
||||
rows = []
|
||||
try:
|
||||
lines = path.read_text(errors="replace").splitlines()
|
||||
except FileNotFoundError:
|
||||
return rows
|
||||
for line in lines[1:]:
|
||||
parts = line.split()
|
||||
if len(parts) <= COL_BRAKE_PRESS:
|
||||
continue # line still being written
|
||||
try:
|
||||
row = [float(p) for p in parts[: COL_BRAKE_PRESS + 1]]
|
||||
except ValueError:
|
||||
continue
|
||||
for p in parts[COL_BRAKE_PRESS + 1:]:
|
||||
try:
|
||||
row.append(float(p))
|
||||
except ValueError:
|
||||
row.append(None)
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
|
||||
def find_logs(game_dir: Path, scenery: str, since: float) -> dict[str, Path]:
|
||||
"""The log.txt / errors.txt of one run; with multiplelogs each scenery gets its own files."""
|
||||
stem = scenery.rsplit(".", 1)[0]
|
||||
found = {}
|
||||
for kind in ("log", "errors"):
|
||||
files = [p for p in (game_dir / "logs").glob(f"{kind} ({stem}) *.txt") if p.stat().st_mtime >= since]
|
||||
if files:
|
||||
found[kind] = max(files, key=lambda p: p.stat().st_mtime)
|
||||
return found
|
||||
|
||||
|
||||
def read_text(path: Path | None) -> str:
|
||||
try:
|
||||
return path.read_text(errors="replace") if path else ""
|
||||
except FileNotFoundError:
|
||||
return ""
|
||||
|
||||
|
||||
# load problems that leave the case without its vehicle; no point waiting for the timeout
|
||||
FATAL_LOG_LINES = ("Bad vehicle:", "Bad trainset:")
|
||||
# wall seconds from start to the first physicslog row before giving up. "Scenario loading
|
||||
# time" in the log is not the end of loading (the trainsets after FirstInit still follow),
|
||||
# and with several simulators loading at once the first rows took well over 15 s
|
||||
STARTUP_TIMEOUT = 120.0
|
||||
# wall seconds past a case's timeout before the runner kills a simulator that didn't end itself
|
||||
KILL_GRACE = 30.0
|
||||
|
||||
|
||||
@dataclass
|
||||
class RunResult:
|
||||
rows: list[list[float]] = field(default_factory=list)
|
||||
exit_code: int | None = None # None: still running when we closed it (the normal end with --watch)
|
||||
verdict: str = "" # the simulator's own line about the test result
|
||||
failure: str = "" # why the run was cut short
|
||||
wall_seconds: float = 0.0
|
||||
logs: dict[str, Path] = field(default_factory=dict)
|
||||
|
||||
|
||||
def run_simulator(exe: Path, game_dir: Path, scenery: str, ini: Path, physicslog: Path,
|
||||
duration: float | None, timeout: float, watch: bool, say) -> RunResult:
|
||||
"""Runs the simulator on the scenery. In test mode it quits by itself and the exit code
|
||||
is the result; with watch it runs in a window and gets closed after `duration`."""
|
||||
physicslog.unlink(missing_ok=True)
|
||||
if watch:
|
||||
cmd = [str(exe), "-s", scenery, "-v", "ghostview", "-ini", str(ini)]
|
||||
else:
|
||||
# the simulator's own watchdog ends a run that takes too long, with the timeout code and its verdict
|
||||
cmd = [str(exe), "--test", "-s", scenery, "-ini", str(ini), "--test-wall-timeout", f"{timeout:g}"]
|
||||
if duration is not None:
|
||||
cmd += ["--test-timeout", f"{duration:g}"]
|
||||
say(" $ " + " ".join(f'"{c}"' if " " in c else c for c in cmd), progress=True)
|
||||
since = time.time() - 1
|
||||
started = time.monotonic()
|
||||
# the test result line goes to stdout; a file, not a pipe, so a chatty run can't block on it
|
||||
stdout = (ini.parent / "stdout.txt").open("w+b")
|
||||
proc = subprocess.Popen(cmd, cwd=game_dir, stdout=stdout, stderr=subprocess.STDOUT)
|
||||
result = RunResult()
|
||||
last_report = 0.0
|
||||
try:
|
||||
while True:
|
||||
time.sleep(0.25) # at timespeed 20 that is 5 s of simulation
|
||||
wall = time.monotonic() - started
|
||||
result.rows = read_physicslog(physicslog)
|
||||
sim_t = result.rows[-1][COL_TIME] if result.rows else 0.0
|
||||
if wall - last_report >= 15:
|
||||
v = result.rows[-1][COL_VELOCITY] if result.rows else 0.0
|
||||
say(f" ... {wall:5.0f}s wall, sim {sim_t:6.1f}s, v={v:6.1f} km/h", progress=True)
|
||||
last_report = wall
|
||||
if proc.poll() is not None:
|
||||
result.exit_code = proc.returncode
|
||||
break
|
||||
if watch and sim_t >= duration:
|
||||
break
|
||||
# in test mode a little later than the simulator's own limit, for a run that can't even end itself
|
||||
if wall > timeout + (0 if watch else KILL_GRACE):
|
||||
result.failure = f"timed out after {wall:.0f}s before {duration}s of simulation"
|
||||
break
|
||||
if not result.rows:
|
||||
result.logs = find_logs(game_dir, scenery, since)
|
||||
fatal = [l.strip() for l in read_text(result.logs.get("errors")).splitlines()
|
||||
if any(k in l for k in FATAL_LOG_LINES)]
|
||||
if fatal:
|
||||
result.failure = "vehicle failed to load: " + " | ".join(fatal)
|
||||
break
|
||||
if wall > STARTUP_TIMEOUT:
|
||||
result.failure = f"no physicslog rows after {STARTUP_TIMEOUT:.0f}s"
|
||||
break
|
||||
finally:
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=10)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
result.wall_seconds = time.monotonic() - started
|
||||
stdout.seek(0)
|
||||
result.verdict = next((line.strip() for line in stdout.read().decode(errors="replace").splitlines()
|
||||
if line.startswith("test:")), "")
|
||||
stdout.close()
|
||||
result.rows = read_physicslog(physicslog)
|
||||
result.logs = find_logs(game_dir, scenery, since)
|
||||
return result
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- checks
|
||||
|
||||
|
||||
def check_starts(rows, min_speed, within):
|
||||
for r in rows:
|
||||
if r[COL_TIME] > within:
|
||||
break
|
||||
if r[COL_VELOCITY] >= min_speed:
|
||||
return True, f"reached {min_speed} km/h at t={r[COL_TIME]:.1f}s"
|
||||
top = max((r[COL_VELOCITY] for r in rows if r[COL_TIME] <= within), default=0.0)
|
||||
return False, f"top speed in the first {within}s was {top:.1f} km/h, wanted {min_speed}"
|
||||
|
||||
|
||||
def check_max_speed(rows, limit, tolerance=0.0):
|
||||
worst = max(rows, key=lambda r: r[COL_VELOCITY])
|
||||
v, t = worst[COL_VELOCITY], worst[COL_TIME]
|
||||
ok = v <= limit + tolerance
|
||||
return ok, f"top speed {v:.1f} km/h at t={t:.1f}s (limit {limit} +{tolerance})"
|
||||
|
||||
|
||||
def _first_moving(rows, moving_speed):
|
||||
return next((i for i, r in enumerate(rows) if r[COL_VELOCITY] >= moving_speed), None)
|
||||
|
||||
|
||||
def _distances(rows):
|
||||
"""Metres travelled up to each row, from the speed; the physicslog has no position."""
|
||||
out, d = [0.0], 0.0
|
||||
for a, b in zip(rows, rows[1:]):
|
||||
d += (a[COL_VELOCITY] + b[COL_VELOCITY]) / 2 / 3.6 * (b[COL_TIME] - a[COL_TIME])
|
||||
out.append(d)
|
||||
return out
|
||||
|
||||
|
||||
def check_brakes(rows, min_pressure, moving_speed=20):
|
||||
start = _first_moving(rows, moving_speed)
|
||||
if start is None:
|
||||
return False, "never moved, so never braked"
|
||||
for r in rows[start:]:
|
||||
if r[COL_BRAKE_PRESS] >= min_pressure:
|
||||
return True, f"brake cylinder {r[COL_BRAKE_PRESS]:.2f} bar at t={r[COL_TIME]:.1f}s, v={r[COL_VELOCITY]:.1f} km/h"
|
||||
return False, f"brake cylinder pressure never reached {min_pressure} bar after moving off"
|
||||
|
||||
|
||||
def check_stops(rows, moving_speed, stop_speed, hold, min_distance=None, max_distance=None):
|
||||
start = _first_moving(rows, moving_speed)
|
||||
if start is None:
|
||||
return False, f"never reached {moving_speed} km/h"
|
||||
dist = _distances(rows)
|
||||
stopped_at = None
|
||||
for i in range(start, len(rows)):
|
||||
r = rows[i]
|
||||
if r[COL_VELOCITY] <= stop_speed:
|
||||
if stopped_at is None:
|
||||
stopped_at = i
|
||||
if r[COL_TIME] - rows[stopped_at][COL_TIME] >= hold:
|
||||
where = dist[stopped_at]
|
||||
detail = f"came to a stop at t={rows[stopped_at][COL_TIME]:.1f}s after {where:.0f} m"
|
||||
if (min_distance is not None and where < min_distance) or (max_distance is not None and where > max_distance):
|
||||
return False, f"{detail}, wanted between {min_distance} and {max_distance} m"
|
||||
return True, detail
|
||||
else:
|
||||
stopped_at = None
|
||||
return False, f"did not stay below {stop_speed} km/h for {hold}s after moving off"
|
||||
|
||||
|
||||
def check_stays_stopped(rows, moving_speed, stop_speed):
|
||||
"""Once stopped after moving off, never moves again (e.g. waiting at a red signal)."""
|
||||
start = _first_moving(rows, moving_speed)
|
||||
if start is None:
|
||||
return False, f"never reached {moving_speed} km/h"
|
||||
stop = next((i for i in range(start, len(rows)) if rows[i][COL_VELOCITY] <= stop_speed), None)
|
||||
if stop is None:
|
||||
return False, f"never came down to {stop_speed} km/h"
|
||||
moved = next((r for r in rows[stop:] if r[COL_VELOCITY] > stop_speed), None)
|
||||
if moved is not None:
|
||||
return False, f"stopped at t={rows[stop][COL_TIME]:.1f}s but moved again at t={moved[COL_TIME]:.1f}s, v={moved[COL_VELOCITY]:.1f} km/h"
|
||||
return True, f"stopped at t={rows[stop][COL_TIME]:.1f}s and stayed until t={rows[-1][COL_TIME]:.1f}s"
|
||||
|
||||
|
||||
def check_distance(rows, max=None, min=None):
|
||||
"""Total distance travelled, in metres."""
|
||||
d = _distances(rows)[-1]
|
||||
ok = (max is None or d <= max) and (min is None or d >= min)
|
||||
bounds = " ".join(s for s in (f">= {min}" if min is not None else "", f"<= {max}" if max is not None else "") if s)
|
||||
return ok, f"travelled {d:.0f} m (wanted {bounds})"
|
||||
|
||||
|
||||
def check_slips(rows, within=None):
|
||||
"""The lead vehicle's wheels slip (or lock in a skid) at some point, e.g. to make sure a slippery rail case does what it's meant to."""
|
||||
for r in rows:
|
||||
if within is not None and r[COL_TIME] > within:
|
||||
break
|
||||
if len(r) > COL_WHEELSLIP and r[COL_WHEELSLIP]:
|
||||
return True, f"wheels slipping at t={r[COL_TIME]:.1f}s, v={r[COL_VELOCITY]:.1f} km/h"
|
||||
return False, "the wheels never slipped"
|
||||
|
||||
|
||||
def check_holds_still(rows, moving_speed, stop_speed, max_distance):
|
||||
"""Once stopped after moving off, the vehicle doesn't creep. Uses the vehicle speed rather than the
|
||||
wheel speed, so it also catches a vehicle sliding on locked wheels."""
|
||||
if not rows or len(rows[0]) <= COL_VEHICLE_VELOCITY or rows[0][COL_VEHICLE_VELOCITY] is None:
|
||||
return False, "the physicslog has no vehicle speed column, the build is too old"
|
||||
speed = [abs(r[COL_VEHICLE_VELOCITY]) for r in rows]
|
||||
start = next((i for i, v in enumerate(speed) if v >= moving_speed), None)
|
||||
if start is None:
|
||||
return False, f"never reached {moving_speed} km/h"
|
||||
stop = next((i for i in range(start, len(rows)) if speed[i] <= stop_speed), None)
|
||||
if stop is None:
|
||||
return False, f"never came down to {stop_speed} km/h"
|
||||
d, top, top_t = 0.0, 0.0, rows[stop][COL_TIME]
|
||||
for i in range(stop + 1, len(rows)):
|
||||
d += (speed[i - 1] + speed[i]) / 2 / 3.6 * (rows[i][COL_TIME] - rows[i - 1][COL_TIME])
|
||||
if speed[i] > top:
|
||||
top, top_t = speed[i], rows[i][COL_TIME]
|
||||
held = rows[-1][COL_TIME] - rows[stop][COL_TIME]
|
||||
detail = f"stopped at t={rows[stop][COL_TIME]:.1f}s, then moved {d:.3f} m in {held:.0f}s, top {top:.4f} km/h at t={top_t:.1f}s"
|
||||
return d <= max_distance, detail
|
||||
|
||||
|
||||
def check_ends_moving(rows, min_speed):
|
||||
"""The run ended with the vehicle still moving, e.g. a pass that didn't wait for the trains to stop."""
|
||||
if not rows:
|
||||
return False, "the physicslog is empty"
|
||||
last = rows[-1]
|
||||
ok = last[COL_VELOCITY] >= min_speed
|
||||
return ok, f"last row t={last[COL_TIME]:.1f}s, v={last[COL_VELOCITY]:.1f} km/h (wanted >= {min_speed})"
|
||||
|
||||
|
||||
def check_slip_clears(rows, moving_speed, stop_speed, within):
|
||||
"""Once the vehicle has stopped after moving off, its wheels stop slipping within `within` seconds
|
||||
(a vehicle left skidding on locked wheels keeps its brakes capped by the sliding adhesion)."""
|
||||
if not rows or len(rows[0]) <= COL_VEHICLE_VELOCITY or rows[0][COL_VEHICLE_VELOCITY] is None:
|
||||
return False, "the physicslog has no vehicle speed column, the build is too old"
|
||||
start = next((i for i, r in enumerate(rows) if abs(r[COL_VEHICLE_VELOCITY]) >= moving_speed), None)
|
||||
if start is None:
|
||||
return False, f"never reached {moving_speed} km/h"
|
||||
stop = next((i for i in range(start, len(rows)) if abs(rows[i][COL_VEHICLE_VELOCITY]) <= stop_speed), None)
|
||||
if stop is None:
|
||||
return False, f"never came down to {stop_speed} km/h"
|
||||
deadline = rows[stop][COL_TIME] + within
|
||||
late = [r for r in rows[stop:] if r[COL_TIME] > deadline and r[COL_WHEELSLIP]]
|
||||
if late:
|
||||
return False, f"stopped at t={rows[stop][COL_TIME]:.1f}s, wheels still slipping at t={late[0][COL_TIME]:.1f}s ({len(late)} rows after the {within}s grace)"
|
||||
return True, f"stopped at t={rows[stop][COL_TIME]:.1f}s, no slipping after t={deadline:.1f}s"
|
||||
|
||||
|
||||
CHECKS = {
|
||||
"slips": check_slips,
|
||||
"slip_clears": check_slip_clears,
|
||||
"holds_still": check_holds_still,
|
||||
"starts": check_starts,
|
||||
"max_speed": check_max_speed,
|
||||
"brakes": check_brakes,
|
||||
"stops": check_stops,
|
||||
"stays_stopped": check_stays_stopped,
|
||||
"distance": check_distance,
|
||||
"ends_moving": check_ends_moving,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- main
|
||||
|
||||
|
||||
def find_exe(explicit: str | None) -> Path:
|
||||
if explicit:
|
||||
return Path(explicit).resolve()
|
||||
candidates = sorted(REPO.glob("cmake-build-*/bin/Release/eu07*.exe"), key=lambda p: p.stat().st_mtime)
|
||||
if not candidates:
|
||||
sys.exit("no eu07 executable found under cmake-build-*/bin/Release, pass --exe")
|
||||
return candidates[-1]
|
||||
|
||||
|
||||
def count_lines(path: Path) -> int:
|
||||
try:
|
||||
return sum(1 for line in path.read_text(errors="replace").splitlines() if line.strip())
|
||||
except FileNotFoundError:
|
||||
return 0
|
||||
|
||||
|
||||
def describe_exit(code: int | None) -> str:
|
||||
if code is None:
|
||||
return "none, still running"
|
||||
name = EXIT_RESULTS.get(code)
|
||||
return f"{code} ({name})" if name else f"{code} (0x{code & 0xFFFFFFFF:08X}, a crash?)"
|
||||
|
||||
|
||||
def run_case(name: str, exe: Path, game_dir: Path, timespeed: float, watch: bool, say) -> bool:
|
||||
case = json.loads((CASES_DIR / f"{name}.json").read_text(encoding="utf-8"))
|
||||
say(f"\n=== {name}: {case.get('description', '')}")
|
||||
out = OUT_DIR / name
|
||||
shutil.rmtree(out, ignore_errors=True)
|
||||
out.mkdir(parents=True)
|
||||
|
||||
# the lead vehicle is named after the case, so parallel runs never share a physicslog
|
||||
vehicle = f"autotest_{name}"
|
||||
scenery = build_scenery(case, game_dir, name, vehicle)
|
||||
ini = out / "autotest.ini"
|
||||
ini.write_text(TEST_INI.format(timespeed=timespeed), encoding="ascii")
|
||||
physicslog = game_dir / "physicslog" / f"{vehicle}.dat"
|
||||
|
||||
duration = float(case["duration"]) if "duration" in case else None
|
||||
# a case that only records `duration` seconds ends on the test timeout; one that says
|
||||
# how the test ends (a pass event, a signal passed at danger...) expects that result
|
||||
expect = case.get("expect", "timeout" if duration is not None else "pass")
|
||||
if expect not in RESULTS:
|
||||
sys.exit(f"{name}: expect must be one of {', '.join(RESULTS)}")
|
||||
if watch and duration is None:
|
||||
sys.exit(f"{name}: --watch needs a case with duration")
|
||||
result = run_simulator(exe, game_dir, scenery, ini, physicslog,
|
||||
duration, float(case.get("timeout", 600)), watch, say)
|
||||
|
||||
# the logs are ours alone (named after the case scenery), move them out of the game dir
|
||||
for kind, path in result.logs.items():
|
||||
shutil.move(path, out / f"{kind}.txt")
|
||||
if physicslog.exists():
|
||||
shutil.move(physicslog, out / physicslog.name)
|
||||
# other trains of the case with a driver, named <something>_<vehicle>, log too
|
||||
for other in physicslog.parent.glob(f"*_{vehicle}.dat"):
|
||||
shutil.move(other, out / other.name)
|
||||
|
||||
ok = True
|
||||
sim_t = result.rows[-1][COL_TIME] if result.rows else 0.0
|
||||
say(f" ran {result.wall_seconds:.0f}s wall, {sim_t:.1f}s of physicslog, results in {out.relative_to(REPO)}")
|
||||
if watch:
|
||||
if result.exit_code is not None:
|
||||
say(f" FAIL simulator exited on its own with code {result.exit_code}")
|
||||
ok = False
|
||||
else:
|
||||
if result.verdict:
|
||||
say(f" {result.verdict}")
|
||||
got = EXIT_RESULTS.get(result.exit_code) if result.exit_code is not None else None
|
||||
if got == "timeout" and "of real time" in result.verdict:
|
||||
got = WALL_TIMEOUT
|
||||
passed = got == expect
|
||||
watchdog = ", from the real time watchdog" if got == WALL_TIMEOUT else ""
|
||||
say(f" {'PASS' if passed else 'FAIL'} exit code {describe_exit(result.exit_code)}{watchdog}, expected {expect}")
|
||||
ok &= passed
|
||||
# a run cut short (the real time watchdog, an error, a crash, or closed by us) could have been writing
|
||||
# the scenery's geometry cache; the simulator checks only the header of it, so the next runs would read
|
||||
# a truncated one. it is written again on the next run
|
||||
if result.failure or (not watch and got in (None, "error", WALL_TIMEOUT)):
|
||||
scenery_cache(game_dir, name).unlink(missing_ok=True)
|
||||
if result.failure:
|
||||
say(f" FAIL {result.failure}")
|
||||
ok = False
|
||||
if not result.rows and case.get("checks"):
|
||||
if not result.failure:
|
||||
say(f" FAIL no physicslog for '{vehicle}'")
|
||||
return False
|
||||
|
||||
for check in case.get("checks", []):
|
||||
params = {k: v for k, v in check.items() if k != "type"}
|
||||
passed, detail = CHECKS[check["type"]](result.rows, **params)
|
||||
say(f" {'PASS' if passed else 'FAIL'} {check['type']}: {detail}")
|
||||
ok &= passed
|
||||
|
||||
errors = count_lines(out / "errors.txt")
|
||||
if errors:
|
||||
say(f" note errors.txt has {errors} line(s)")
|
||||
if case.get("fail_on_errors") and errors:
|
||||
ok = False
|
||||
return ok
|
||||
|
||||
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
ap.add_argument("cases", nargs="*", help="case names from cases/ (default: all)")
|
||||
ap.add_argument("--game-dir", default=os.environ.get("EU07_GAME_DIR"),
|
||||
help="game install with scenery/ and dynamic/ (or EU07_GAME_DIR)")
|
||||
ap.add_argument("--exe", help="simulator executable (default: newest cmake-build-*/bin/Release/eu07*.exe)")
|
||||
ap.add_argument("--watch", action="store_true",
|
||||
help="run in a visible window in real time (see --timespeed) instead of the test mode, "
|
||||
"closed after the case's duration; the exit code isn't checked")
|
||||
ap.add_argument("--timespeed", type=float, default=1.0,
|
||||
help="with --watch: simulation time multiplier, the simulator offers 1, 5, 20 and 60 (default 1)")
|
||||
ap.add_argument("-j", "--jobs", type=int, default=1,
|
||||
help="cases run at once, each in a simulator of its own (default 1)")
|
||||
args = ap.parse_args()
|
||||
|
||||
if not args.game_dir:
|
||||
sys.exit("pass --game-dir or set EU07_GAME_DIR")
|
||||
game_dir = Path(args.game_dir).resolve()
|
||||
exe = find_exe(args.exe)
|
||||
print(f"exe: {exe}\ngame: {game_dir}")
|
||||
|
||||
names = args.cases or sorted(p.stem for p in CASES_DIR.glob("*.json"))
|
||||
missing = [n for n in names if not (CASES_DIR / f"{n}.json").exists()]
|
||||
if missing:
|
||||
sys.exit("no such case: " + ", ".join(missing))
|
||||
|
||||
started = time.monotonic()
|
||||
results = {}
|
||||
if args.jobs <= 1:
|
||||
def say(line, progress=False):
|
||||
print(line, flush=True)
|
||||
for n in names:
|
||||
results[n] = run_case(n, exe, game_dir, args.timespeed, args.watch, say)
|
||||
else:
|
||||
# each case prints its block when it is done, so parallel output does not interleave
|
||||
def job(n):
|
||||
lines = []
|
||||
def say(line, progress=False):
|
||||
if not progress:
|
||||
lines.append(line)
|
||||
ok = run_case(n, exe, game_dir, args.timespeed, args.watch, say)
|
||||
return n, ok, lines
|
||||
with ThreadPoolExecutor(max_workers=args.jobs) as pool:
|
||||
for n in names:
|
||||
print(f"started {n}", flush=True)
|
||||
for fut in as_completed([pool.submit(job, n) for n in names]):
|
||||
n, ok, lines = fut.result()
|
||||
print("\n".join(lines), flush=True)
|
||||
results[n] = ok
|
||||
|
||||
print(f"\n=== summary ({time.monotonic() - started:.0f}s)")
|
||||
for n in names:
|
||||
print(f" {'PASS' if results[n] else 'FAIL'} {n}")
|
||||
return 0 if all(results.values()) else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
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