18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-17 01:04:09 +01:00

refactor(simulation): the rules of the test mode in a file of their own, with unit tests

The command line options of the test mode and the end conditions checked after
each frame are now plain functions in simulation/simulationtestrules.cpp, which
needs nothing of the running simulation: parse_test_command_line() and
evaluate_frame(). The file is part of the core library, so the unit tests check
them (tests/unit/test_test_mode.cpp): the --test-timeout value, values of other
options not taken for options, a pass that waits for the stop, the standstill,
the timeout. test_manager only gathers what a frame brought and acts on the
verdict. No change in behaviour.
This commit is contained in:
jerrrrycho
2026-11-08 11:20:52 +01:00
parent 62526e9d6a
commit 486a714f52
7 changed files with 452 additions and 110 deletions

View File

@@ -25,16 +25,6 @@ http://mozilla.org/MPL/2.0/.
#include <format>
#include <memory>
namespace {
// the cell holds what the scenery wrote, so the values are whole numbers; the margin only keeps a stray fraction out
bool holds(double const Value, double const Expected)
{
return std::abs(Value - Expected) < 1e-6;
}
} // namespace
namespace simulation {
test_manager &test()
@@ -43,21 +33,6 @@ test_manager &test()
return instance;
}
std::string_view to_string(test_result const Result)
{
using enum test_result;
switch (Result)
{
case pass: return "pass";
case fail: return "fail";
case signal_passed_at_danger: return "signal passed at danger";
case timeout: return "timeout";
case standstill: return "standstill";
case error: return "error";
}
return "unknown";
}
void test_manager::init_result_cell() const
{
auto cell { std::make_unique<TMemCell>(scene::node_data{0, -1, std::string(result_cell), "memcell"}) };
@@ -73,8 +48,7 @@ void test_manager::start()
if (m_started)
return;
m_started = true;
m_time = 0.0;
m_resttime = 0.0;
m_progress = test_progress {};
if (simulation::Vehicles.sequence().empty())
{
// most likely the scenery wasn't found, or it isn't a test scenery
@@ -94,48 +68,25 @@ void test_manager::update(double const Deltatime)
if (false == m_started || m_finished)
return;
m_time += Deltatime;
test_frame frame { Deltatime, std::nullopt, {},
std::ranges::none_of(simulation::Vehicles.sequence(), [](TDynamicObject const *Vehicle) { return std::abs(Vehicle->GetVelocity()) > 0.01; }) };
if (auto const *cell = simulation::Memory.find(std::string(result_cell)))
{
auto const value { cell->Value1() };
auto const reason { cell->Text().empty() ? std::string() : std::format(" ({})", cell->Text()) };
if (holds(value, 0.0))
{
finish(test_result::fail, std::format("__test.result set to 0{}", reason));
return;
}
if (holds(value, 1.0) && false == Global.test.no_movement_before_pass)
{
finish(test_result::pass, std::format("__test.result set to 1{}", reason));
return;
}
if (holds(value, 1.0) && false == m_passrequested)
{
m_passrequested = true;
WriteLog(std::format("test: pass requested at {:.1f} s{}, waiting for every vehicle to stop", m_time, reason));
}
frame.reported = cell->Value1();
frame.reason = cell->Text();
}
auto const atrest { std::ranges::none_of(simulation::Vehicles.sequence(),
[](TDynamicObject const *Vehicle) { return std::abs(Vehicle->GetVelocity()) > 0.01; }) };
m_resttime = atrest ? m_resttime + Deltatime : 0.0;
if (m_passrequested && m_resttime >= pass_settle_time)
auto const requestedbefore { m_progress.passrequested };
auto const verdict { evaluate_frame(m_progress, frame, test_limits { Global.test.timeout, Global.test.standstill, Global.test.pass_on_standstill, Global.test.no_movement_before_pass }) };
if (verdict.has_value())
{
finish(test_result::pass, "__test.result set to 1 and every vehicle stopped");
finish(verdict->result, verdict->reason);
return;
}
if (Global.test.standstill > 0.0 && m_resttime >= Global.test.standstill)
if (m_progress.passrequested && false == requestedbefore)
{
auto const reason { std::format("every vehicle stood still for {:.0f} s", Global.test.standstill) };
finish(Global.test.pass_on_standstill ? test_result::pass : test_result::standstill, reason);
return;
}
if (Global.test.timeout > 0.0 && m_time >= Global.test.timeout)
{
finish(test_result::timeout, std::format("no result after {:.0f} s", Global.test.timeout));
return;
WriteLog(std::format("test: pass requested at {:.1f} s{}, waiting for every vehicle to stop", m_progress.time,
frame.reason.empty() ? std::string() : std::format(" ({})", frame.reason)));
}
}
@@ -149,7 +100,7 @@ void test_manager::signal_passed_at_danger(std::string_view const Vehicle, std::
}
if (false == Global.test.fail_if_stop_overran)
{
WriteLog(std::format("test: {} at {:.1f} s, allowed by test.fail_if_stop_overran", reason, m_time));
WriteLog(std::format("test: {} at {:.1f} s, allowed by test.fail_if_stop_overran", reason, m_progress.time));
return;
}
finish(test_result::signal_passed_at_danger, reason);
@@ -168,7 +119,7 @@ bool test_manager::conclude(test_result const Result, std::string_view const Rea
m_finished = true;
m_result = Result;
auto const line { std::format("test: {} (exit code {}) after {:.1f} s of simulation time: {}", to_string(Result), static_cast<int>(Result), m_time, Reason) };
auto const line { std::format("test: {} (exit code {}) after {:.1f} s of simulation time: {}", to_string(Result), static_cast<int>(Result), m_progress.time, Reason) };
if (Result == test_result::pass)
WriteLog(line);
else