mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-14 11:13:34 +01:00
02e29f6971
eu07 --test -s <scenery> [--test-timeout <s>] runs the scenery in ghostview with
the null renderer (models loaded, no textures), a hidden window, no sound,
network or python, and in fixed steps of 0.03 s of simulation time per frame
(three 10 ms physics steps) as fast as it can. Without -seed it uses a fixed
seed, so two runs give byte-identical physicslogs.
The scenery reports its result to the __test.result memory cell, which the
simulator always creates: value 1 passes once every vehicle has stood still for
1 s, value 0 fails at once. The run ends with exit code
0 pass, 1 fail,
2 a train passed a signal at stop (SetVelocity 0 0, as seen in its driver's
speed table; SetVelocity 0 x on automatic block doesn't count),
3 timeout (test.timeout, default 3600 s of simulation time),
4 standstill (every vehicle still for test.standstill s, default 300, with no
result; a pass with test.pass_on_standstill yes),
5 error (no -s, the scenery didn't load or has no vehicles, an exception).
The test.* keys go in the scenery's config block; test.fail_if_stop_overran no
only logs a signal passed at danger. Outside the test mode a signal passed at
danger is logged.
The null renderer gets a ui backend which draws nothing, hands out the null
texture and material instead of throwing, and ends the ui frame. A GL context
is still made for the hidden window, without asking for a version, as parts
of the ui create textures with gl calls of their own. No crash dialog or
message box in test mode; the window code no longer needs a monitor.
67 lines
2.6 KiB
C++
67 lines
2.6 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <string>
|
|
|
|
// integration test mode (eu07 --test -s <scenery>, eu07/maszyna#541): the scenery runs unattended in a tight
|
|
// fixed-step loop and the simulator quits with an exit code saying how the test went
|
|
namespace simulation {
|
|
|
|
// exit codes of a test run; public, scripts and CI read them
|
|
enum class test_result : int {
|
|
pass = 0, // __test.result set to 1, then every vehicle came to rest (or test.pass_on_standstill)
|
|
fail = 1, // __test.result set to 0
|
|
signal_passed_at_danger = 2, // a train went past a stop signal (SetVelocity 0 0), unless test.fail_if_stop_overran no
|
|
timeout = 3, // test.timeout seconds of simulation time went by without a result
|
|
standstill = 4, // every vehicle stood still for test.standstill seconds without a result
|
|
error = 5, // the run could not start (no -s, the scenery failed to load) or the simulator threw
|
|
};
|
|
|
|
std::string_view to_string(test_result Result);
|
|
|
|
class test_manager {
|
|
|
|
public:
|
|
// name of the memory cell a scenery reports its result to
|
|
static constexpr std::string_view result_cell { "__test.result" };
|
|
// how long everything has to stand before a requested pass is granted [s]
|
|
static constexpr double pass_settle_time { 1.0 };
|
|
// fixed simulation time step of one frame in test mode [s]: 3 physics steps of 10 ms
|
|
static constexpr double frame_step { 0.03 };
|
|
|
|
// creates the result cell; called with the other scripting interface cells, before the scenery is read
|
|
void init_result_cell();
|
|
// the simulation is ready: start the clocks
|
|
void start();
|
|
// checks the end conditions after a simulation frame of Deltatime seconds
|
|
void update(double Deltatime);
|
|
// reported by a driver whose train went past a signal showing stop
|
|
void signal_passed_at_danger(std::string const &Vehicle, std::string const &Signal);
|
|
// ends the test with given result; the first call wins
|
|
void finish(test_result Result, std::string const &Reason);
|
|
|
|
bool finished() const { return m_finished; }
|
|
// exit code of the process: the result, or error while the test hasn't finished
|
|
int exit_code() const { return static_cast<int>(m_finished ? m_result : test_result::error); }
|
|
|
|
private:
|
|
bool m_started { false };
|
|
bool m_finished { false };
|
|
test_result m_result { test_result::error };
|
|
bool m_passrequested { false };
|
|
double m_time { 0.0 }; // simulation time since the start [s]
|
|
double m_resttime { 0.0 }; // how long every vehicle has been standing [s]
|
|
};
|
|
|
|
extern test_manager Test;
|
|
|
|
} // namespace simulation
|