18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 07:24:57 +01:00
Files
maszyna/tests/unit/test_utilities.cpp
maj00r 1b26caca24 fix: inverted clamp bounds give the upper bound again, as the old clamp did (#412)
* fix: inverted clamp bounds give the upper bound again, as the old clamp did

The project's own clamp() of 26.05 applied the lower bound first and the
upper one last, so bounds given the wrong way round always gave the upper
one. Its calls became std::clamp (undefined for such bounds) and, where the
bounds can cross, safe_clamp, which swapped them instead. Neither gives the
old result.

- safe_clamp is the old clamp again, min(max(value, lo), hi). This restores
  26.05 at every place it is used, among them the AI's dynamic brake test
  (its demand was fAccThreshold x1.21, the swap made it x1.01), the
  generator voltage, the heavy cargo acceleration of the AI and the EP
  correction of the brake.
- The cab camera is kept inside the cab with safe_clamp. The bounds come
  from the .mmd as written and some cabs have them reversed (the B cars of
  SA134 and 21xM, ET40, 754); with std::clamp the camera jumped between
  the two bounds every frame on MSVC, as its result is fed back.

* fix: every call of the old clamp gives what it gave up to 26.05.1

d1f16411 (#99) made every call of the project's clamp() std::clamp. Where the bounds come from the data or
are computed at runtime they can cross, and then std::clamp gives another result (undefined behaviour;
MSVC gives the lower bound unless the value is above the upper one) where the old clamp gave the upper
bound. These calls use safe_clamp, the old clamp, too:

- Mover: the pantograph pressure (MaxPress), the compressor switch (CompressorListPosNo), the coupler
  distance (DmaxB, DmaxC), the engine revolutions, the eimic ramp (CtrlDelay), the eimic limit
  (eimic_max), the speed control ramp (PowerUpSpeed, PowerDownSpeed), the load (MaxLoad), the magnet of
  the security system (Dim.L);
- DynObj: the coupler distance of the buffers (DmaxB), the axle distance (Dim.L);
- Train: the brake handle positions (BrakeCtrlPosNo, the range of the handle);
- the legacy renderer: the mouse pick (the window size).

With the bounds in order nothing changes. Calls whose bounds the code keeps in order (constants,
SplineFidelity 1-4, the season table, the guarded output calibration) give the same result with
std::clamp and stay as they are.

The load offset takes its arguments in the 26.05.1 order again; fa2ed089 swapped them, which with the
old clamp differs only for a negative load.

The bump at a rail joint gives the old result again. Up to 26.05.1 its clamps had 0 in place of the
value (since 96f43e11 and 4d72d352), and the old clamp made that the headroom Vmax - (Vel + 0.32 Vmax),
negative above 68% of the top speed, capped from above only; d464628a and 03bfbb13 kept it at 0 or
above. Only damaged track has the bump: a damage flag in the .scn, a derailer set by an event, a track
made on a derailment.

The interior light of the cab in the 3.3 renderer is computed in double again, as before d1f16411.

The call added since (stepped_uc_value, 00955513) keeps what master does: bounds given the other way
round are put in order.

* fix: the alpha of a particle in the legacy renderer as up to 26.05.1, the NaN cases of the clamp tested

Up to 26.05.1 the alpha was clamp<std::uint8_t>( particle.opacity * 255, 0, 255 ): the float was
made a byte first, so the clamp did nothing and an opacity over 1 (a smoke max_opacity over 1)
wrapped round, 1.2 giving 50. The move to std::clamp made it 255. It's made a byte as then again,
through int: the byte the x86-64 compilers gave, without the undefined behaviour of that conversion
(MSVC makes the same two instructions of both). openglparticles.cpp goes with feat/gl46-migration;
its opengl33 counterpart, std::clamp( opacity, 0, 1 ), already gives what 26.05.1 gave.

The tests pin what the old clamp gave with NaN: a NaN value stays NaN, a NaN bound doesn't clamp.
The checks named after the AI braking test and the bump at a rail joint say they test the helper with
the arguments of those calls, not the calls.

* test: the includes of the clamp tests before the project's headers

<cmath> and <limits> go up, after the test headers, so the change no longer touches the lines
#416 adds its includes after. With both merged <cmath> is included twice, which is harmless.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:29 +01:00

796 lines
32 KiB
C++

#include "stdafx.h"
#include "doctest.h"
#include "scratch.h"
#include <cmath>
#include <limits>
#include "utilities/Globals.h"
#include "utilities/utilities.h"
// the helpers of utilities/utilities.cpp and utilities.h as they behave now: the numbers and texts they give, their
// oddities included. the ones which look like mistakes are listed in COVERAGE.md. the helpers which read from a
// parser (LoadPoint, the sets, the map) are in test_parser.cpp
namespace {
// puts the debug mode back as it was
struct debug_mode {
bool const before{DebugModeFlag};
explicit debug_mode(bool const Enabled) { DebugModeFlag = Enabled; }
debug_mode(debug_mode const &) = delete;
debug_mode &operator=(debug_mode const &) = delete;
~debug_mode() { DebugModeFlag = before; }
};
// the polish letters in windows-1250, as in test_win1250.cpp
std::string const kWin1250{"\xA5\xC6\xCA\xA3\xD1\xD3\x8C\x8F\xAF\xB9\xE6\xEA\xB3\xF1\xF3\x9C\x9F\xBF"};
} // namespace
// time ----------------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: the time between two times of a day is in minutes, the shorter way round midnight") {
CHECK(CompareTime(10, 0, 10, 30) == 30.0);
CHECK(CompareTime(10, 30, 10, 0) == -30.0);
// 23:50 to 0:05 is a quarter later, not a day earlier
CHECK(CompareTime(23, 50, 0, 5) == 15.0);
CHECK(CompareTime(0, 5, 23, 50) == -15.0);
// half a day stays as it is counted
CHECK(CompareTime(0, 0, 12, 0) == 720.0);
CHECK(CompareTime(12, 0, 0, 0) == -720.0);
// a negative hour stands for no time given
CHECK(CompareTime(10, 0, -1, 30) == 0.0);
}
TEST_CASE("utilities: the current time is given as a text") {
std::string now;
try {
now = Now();
}
catch (std::runtime_error const &error) {
// the local time needs the time zone database of the system, which a bare one may be without
MESSAGE("Now() has no time zone to tell the local time in: " << error.what());
return;
}
CHECK_FALSE(now.empty());
}
TEST_CASE("utilities: a time is taken apart the same way in every thread") {
// 2001-09-09 01:46:40 UTC, a Sunday
std::time_t const time{1000000000};
auto const utc{utc_tm(time)};
CHECK(utc.tm_year == 101);
CHECK(utc.tm_mon == 8);
CHECK(utc.tm_mday == 9);
CHECK(utc.tm_hour == 1);
CHECK(utc.tm_min == 46);
CHECK(utc.tm_sec == 40);
CHECK(utc.tm_wday == 0);
auto const epoch{utc_tm(0)};
CHECK(epoch.tm_year == 70);
CHECK(epoch.tm_yday == 0);
CHECK(epoch.tm_hour == 0);
CHECK(epoch.tm_wday == 4);
// the local time is the one the system puts back together into the same moment
auto local{local_tm(time)};
CHECK(std::mktime(&local) == time);
}
// flags ---------------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: setting a flag tells whether it changed anything, a negative value clears") {
int flags{0};
CHECK(SetFlag(flags, 4));
CHECK(flags == 4);
CHECK_FALSE(SetFlag(flags, 4));
// some of the bits set already still count as a change
CHECK(SetFlag(flags, 6));
CHECK(flags == 6);
CHECK(TestFlag(flags, 6));
CHECK_FALSE(TestFlag(flags, 3));
CHECK(TestFlagAny(flags, 3));
CHECK_FALSE(TestFlagAny(flags, 1));
CHECK(SetFlag(flags, -4));
CHECK(flags == 2);
CHECK_FALSE(SetFlag(flags, -4));
CHECK_FALSE(SetFlag(flags, 0));
CHECK(flags == 2);
}
TEST_CASE("utilities: clearing a flag needs all of its bits set") {
int flags{1};
CHECK_FALSE(ClearFlag(flags, 3));
CHECK(flags == 1);
CHECK(ClearFlag(flags, 1));
CHECK(flags == 0);
// no bits at all are always there to clear
CHECK(ClearFlag(flags, 0));
CHECK(flags == 0);
}
// random numbers ------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: random whole numbers are within the bounds, both included, given in any order") {
std::set<int> seen;
for (auto draw{0}; draw < 200; ++draw) {
auto const value{Random(3, 7)};
CHECK(value >= 3);
CHECK(value <= 7);
seen.insert(value);
auto const swapped{Random(7, 3)};
CHECK(swapped >= 3);
CHECK(swapped <= 7);
}
CHECK(seen.size() == 5);
CHECK(Random(5, 5) == 5);
}
TEST_CASE("utilities: random numbers are within the bounds given in any order") {
for (auto draw{0}; draw < 200; ++draw) {
auto const value{Random(2.0, 4.0)};
CHECK(value >= 2.0);
CHECK(value <= 4.0);
auto const swapped{Random(4.0, 2.0)};
CHECK(swapped >= 2.0);
CHECK(swapped <= 4.0);
auto const unit{Random()};
CHECK(unit >= 0.0);
CHECK(unit <= 1.0);
auto const upto{Random(10.0)};
CHECK(upto >= 0.0);
CHECK(upto <= 10.0);
auto const local{LocalRandom(-1.0, 1.0)};
CHECK(local >= -1.0);
CHECK(local <= 1.0);
auto const localswapped{LocalRandom(1.0, -1.0)};
CHECK(localswapped >= -1.0);
CHECK(localswapped <= 1.0);
auto const localunit{LocalRandom()};
CHECK(localunit >= 0.0);
CHECK(localunit <= 1.0);
auto const localupto{LocalRandom(10.0)};
CHECK(localupto >= 0.0);
CHECK(localupto <= 10.0);
}
}
TEST_CASE("utilities: the same seed gives the same random numbers") {
std::vector<int> first;
Global.random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
first.push_back(Random(0, 1000000));
}
std::vector<int> second;
Global.random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
second.push_back(Random(0, 1000000));
}
CHECK(first == second);
}
TEST_CASE("utilities: the local random numbers have an engine of their own") {
Global.local_random_engine.seed(5);
auto const first{LocalRandom()};
Global.local_random_engine.seed(5);
// the numbers of the simulation drawn in between don't move it
Random();
Random(1, 6);
CHECK(LocalRandom() == first);
}
TEST_CASE("utilities: a seed of the system's entropy is there to be drawn") {
auto const first{true_random_seed()};
auto const second{true_random_seed()};
CHECK((first != 0 || second != 0));
}
TEST_CASE("utilities: the seed a text stands for is its number, or its hash the way Java counts it") {
CHECK(seed_of("12345") == 12345u);
CHECK(seed_of("0") == 0u);
CHECK(seed_of("4294967295") == 4294967295u);
CHECK(seed_of("hello") == 99162322u);
CHECK(seed_of("test") == 3556498u);
CHECK(seed_of("") == 0u);
// a number which isn't a seed is a word: negative, or too big
CHECK(seed_of("-5") == 1448u);
CHECK(seed_of("4294967296") == 3632702254u);
// the bytes over ascii count as positive
CHECK(seed_of("\xB9") == 185u);
// a word starting with digits is taken for the number in front of it
CHECK(seed_of("12abc") == 12u);
}
TEST_CASE("utilities: a version 4 uuid is drawn from the random numbers of the simulation") {
auto const id{generate_uuid_v4()};
REQUIRE(id.size() == 36);
auto wrong{0};
for (std::size_t index{0}; index < id.size(); ++index) {
auto const character{id[index]};
if (index == 8 || index == 13 || index == 18 || index == 23) {
wrong += (character == '-' ? 0 : 1);
}
else {
wrong += ((character >= '0' && character <= '9') || (character >= 'a' && character <= 'f') ? 0 : 1);
}
}
CAPTURE(id);
CHECK(wrong == 0);
// the version and the variant
CHECK(id[14] == '4');
CHECK((id[19] == '8' || id[19] == '9' || id[19] == 'a' || id[19] == 'b'));
CHECK(generate_uuid_v4() != id);
// the same seed gives the same one
Global.random_engine.seed(11);
auto const first{generate_uuid_v4()};
Global.random_engine.seed(11);
CHECK(generate_uuid_v4() == first);
}
TEST_CASE("utilities: a failure is drawn only over the threshold, the likelier the less the value is over it") {
debug_mode const mode{false};
for (auto draw{0}; draw < 50; ++draw) {
// at the threshold and under it: never
CHECK_FALSE(FuzzyLogic(1.0, 2.0, 1000.0));
CHECK_FALSE(FuzzyLogic(2.0, 2.0, 1000.0));
CHECK_FALSE(FuzzyLogicAI(1.0, 2.0, 1000.0));
CHECK_FALSE(FuzzyLogicAI(2.0, 2.0, 1000.0));
// a chance over 1 is a certainty, a chance of 0 never comes
CHECK(FuzzyLogic(2.0, 1.0, 10.0));
CHECK(FuzzyLogicAI(2.0, 1.0, 10.0));
CHECK_FALSE(FuzzyLogic(2.0, 1.0, 0.0));
CHECK_FALSE(FuzzyLogicAI(2.0, 1.0, 0.0));
}
}
TEST_CASE("utilities: the debug mode keeps the failures away, but not the ones drawn regardless of it") {
debug_mode const mode{true};
CHECK_FALSE(FuzzyLogic(2.0, 1.0, 10.0));
CHECK(FuzzyLogicAI(2.0, 1.0, 10.0));
}
// texts ---------------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: a text is split at every separator, the empty parts kept") {
CHECK(Split("a,b,,c", ',') == std::vector<std::string>{"a", "b", "", "c"});
CHECK(Split("abc", ',') == std::vector<std::string>{"abc"});
CHECK(Split("a,", ',') == std::vector<std::string>{"a", ""});
CHECK(Split(",a", ',') == std::vector<std::string>{"", "a"});
CHECK(Split("10|20", '|') == std::vector<std::string>{"10", "20"});
// an empty text has no parts at all
CHECK(Split("", ',').empty());
}
TEST_CASE("utilities: a name is split from the number it ends with") {
CHECK(split_string_and_number("abc12") == std::pair<std::string, int>{"abc", 12});
CHECK(split_string_and_number("t1") == std::pair<std::string, int>{"t", 1});
CHECK(split_string_and_number("abc") == std::pair<std::string, int>{"abc", 0});
CHECK(split_string_and_number("") == std::pair<std::string, int>{"", 0});
CHECK(split_string_and_number("12") == std::pair<std::string, int>{"", 12});
// a minus is a part of the number
CHECK(split_string_and_number("x-5") == std::pair<std::string, int>{"x", -5});
// the number is the first one, what follows it is dropped
CHECK(split_string_and_number("a1b2") == std::pair<std::string, int>{"a", 1});
}
TEST_CASE("utilities: a name with a hyphen, or with a number too big, is an exception") {
// the hyphen is taken for the start of a number
CHECK_THROWS_AS(split_string_and_number("a-b"), std::invalid_argument);
CHECK_THROWS_AS(split_string_and_number("door-"), std::invalid_argument);
CHECK_THROWS_AS(split_string_and_number("a99999999999"), std::out_of_range);
}
TEST_CASE("utilities: whole numbers are written to a width, padded with spaces on the left") {
CHECK(to_string(5, 3) == " 5");
CHECK(to_string(-5, 4) == " -5");
CHECK(to_string(12345, 3) == "12345");
CHECK(to_string(7, 0) == "7");
}
TEST_CASE("utilities: numbers are written with the decimals asked for, and to a width") {
CHECK(to_string(3.14159, 2) == "3.14");
CHECK(to_string(1.0, 3) == "1.000");
CHECK(to_string(-1.26, 1) == "-1.3");
CHECK(to_string(2.675, 2) == "2.67");
// a half rounds to the even digit
CHECK(to_string(2.5, 0) == "2");
CHECK(to_string(3.14159, 2, 8) == " 3.14");
CHECK(to_string(-1.5, 1, 6) == " -1.5");
// a number wider than the width isn't cut
CHECK(to_string(123.456, 1, 3) == "123.5");
CHECK(to_string(true) == "true");
CHECK(to_string(false) == "false");
}
TEST_CASE("utilities: numbers are written in hex with capital digits, the negative ones as unsigned") {
CHECK(to_hex_str(255) == "0x00FF");
CHECK(to_hex_str(255, 2) == "0xFF");
CHECK(to_hex_str(0, 8) == "0x00000000");
CHECK(to_hex_str(0x12345) == "0x12345");
CHECK(to_hex_str(-1) == "0xFFFFFFFF");
}
TEST_CASE("utilities: the minutes of a timetable are written with their tenths as a raised digit") {
// two characters for the minutes, then the digit, a space for no tenths; the digits are utf-8
CHECK(to_minutes_str(5.5f, true, 3) == "05\xE2\x81\xB5");
CHECK(to_minutes_str(7.9f, true, 3) == "07\xE2\x81\xB9");
CHECK(to_minutes_str(0.0f, true, 3) == "00 ");
CHECK(to_minutes_str(5.0f, false, 3) == " 5 ");
CHECK(to_minutes_str(12.3f, false, 3) == "12\xC2\xB3");
CHECK(to_minutes_str(5.0f, false, 5) == " 5 ");
// only the last digits fit
CHECK(to_minutes_str(123.0f, false, 3) == "23 ");
}
TEST_CASE("utilities: minutes can't be written a single character wide") {
// the padding is counted as one character less than nothing
CHECK_THROWS_AS(to_minutes_str(5.0f, false, 1), std::length_error);
}
TEST_CASE("utilities: a text is read as a whole number, with a default for an empty one") {
CHECK(stol_def("42", 7) == 42);
CHECK(stol_def("-3", 7) == -3);
CHECK(stol_def(" 15 ", 7) == 15);
CHECK(stol_def("12abc", 7) == 12);
CHECK(stol_def("", 7) == 7);
CHECK(stol_def(" ", 7) == 7);
// a text which isn't a number gives zero, not the default
CHECK(stol_def("abc", 7) == 0);
}
TEST_CASE("utilities: the case of the letters of ascii is changed") {
CHECK(ToLower("AbC-12 Zz") == "abc-12 zz");
CHECK(ToUpper("AbC-12 Zz") == "ABC-12 ZZ");
CHECK(ToLower("").empty());
// the other bytes stay, in the "C" locale the tests run in
CHECK(ToUpper("\xB3\xC5\x82") == "\xB3\xC5\x82");
CHECK(ToLower("\xA3\xC5\x81") == "\xA3\xC5\x81");
}
TEST_CASE("utilities: the polish letters of windows-1250 are replaced with the letters of ascii") {
auto text{kWin1250};
win1250_to_ascii(text);
CHECK(text == "ACELNOSZZacelnoszz");
// the rest of the text stays, other letters with marks too
std::string other{"tor 1, caf\xE9"};
win1250_to_ascii(other);
CHECK(other == "tor 1, caf\xE9");
}
TEST_CASE("utilities: a text for the timetable loses its marks, control characters and, when asked, underscores") {
// the letters up to 0xB0, which the table has in the same place whatever the compiler
CHECK(Bezogonkow("\xA5\xA3\x8C\x8F\xAF\x9C\x9F") == "ALSZZsz");
CHECK(Bezogonkow("Warszawa Zachodnia") == "Warszawa Zachodnia");
CHECK(Bezogonkow("a\tb\nc") == "a b c");
CHECK(Bezogonkow("Bia\xA3" "a_Podlaska") == "BiaLa_Podlaska");
CHECK(Bezogonkow("Bia\xA3" "a_Podlaska", true) == "BiaLa Podlaska");
}
TEST_CASE("utilities: the polish letters from 0xB2 on lose their marks only in a build which makes one byte of the table's mark") {
// the table of Bezogonkow() has a plus-minus sign for 0xB1, written as the character in the source, a utf-8 file.
// MSVC puts it into the table as the one byte of the system's code page, and the table is as it was meant.
// GCC and Clang put the two bytes of utf-8 there, which moves the entries after it by one (see COVERAGE.md)
if (Bezogonkow("\xB1") == "\xB1") {
CHECK(Bezogonkow(kWin1250) == "ACELNOSZZacelnoszz");
}
else {
// the first byte of the sign for 0xB1, the second for 0xB2, and each letter after them as the entry before its own
CHECK(Bezogonkow("\xB1\xB2") == "\xC2\xB1");
CHECK(Bezogonkow(kWin1250) == "ALELDNSZZ,le,dnszl");
}
}
TEST_CASE("utilities: utf-8 is decoded into code points of one to four bytes") {
std::u32string decoded{U"old"};
REQUIRE(utf8_to_utf32("a\xC5\x82\xE2\x82\xAC\xF0\x9F\x98\x80", decoded));
REQUIRE(decoded.size() == 4);
CHECK(decoded[0] == U'a');
CHECK(decoded[1] == char32_t{0x142});
CHECK(decoded[2] == char32_t{0x20AC});
CHECK(decoded[3] == char32_t{0x1F600});
REQUIRE(utf8_to_utf32("", decoded));
CHECK(decoded.empty());
}
TEST_CASE("utilities: what isn't utf-8 is refused") {
std::u32string decoded;
// a byte which can't start a sequence
CHECK_FALSE(utf8_to_utf32("\x80", decoded));
CHECK_FALSE(utf8_to_utf32("\xF8\x88\x80\x80\x80", decoded));
// a sequence cut short, or continued with a byte which doesn't continue one
CHECK_FALSE(utf8_to_utf32("\xE2\x82", decoded));
CHECK_FALSE(utf8_to_utf32("\xC5\x41", decoded));
// a code point written longer than it needs
CHECK_FALSE(utf8_to_utf32("\xC0\x80", decoded));
CHECK_FALSE(utf8_to_utf32("\xE0\x80\xAF", decoded));
// a surrogate, and a code point past the last one
CHECK_FALSE(utf8_to_utf32("\xED\xA0\x80", decoded));
CHECK_FALSE(utf8_to_utf32("\xF4\x90\x80\x80", decoded));
// what was decoded before the bad byte is left in the output
CHECK_FALSE(utf8_to_utf32("ab\x80", decoded));
CHECK(decoded == std::u32string{U"ab"});
}
TEST_CASE("utilities: windows-1250 is decoded into code points, the unassigned bytes into zeros") {
std::u32string decoded{U"old"};
win1250_to_utf32("A\xB3\xA5\x80\xFF\x81", decoded);
REQUIRE(decoded.size() == 6);
CHECK(decoded[0] == U'A');
CHECK(decoded[1] == char32_t{0x142});
CHECK(decoded[2] == char32_t{0x104});
CHECK(decoded[3] == char32_t{0x20AC});
CHECK(decoded[4] == char32_t{0x2D9});
CHECK(decoded[5] == char32_t{0});
win1250_to_utf32("", decoded);
CHECK(decoded.empty());
}
TEST_CASE("utilities: the value of a key is the text after its equals sign, up to the next space") {
CHECK(extract_value("Key", "a=1 Key=val b=2") == "val");
CHECK(extract_value("Key", "Key=val") == "val");
CHECK(extract_value("Key", "a=1 Key= val b=2") == "val");
CHECK(extract_value("Key", "a=1 b=2").empty());
// the key is a whole word, in its case
CHECK(extract_value("Key", "MyKey=val key=other").empty());
}
TEST_CASE("utilities: a key without a value takes the next key for it, and is an exception at the end of the text") {
CHECK(extract_value("Key", "Key= Other=5") == "Other=5");
CHECK_THROWS_AS(extract_value("Key", "a=1 Key="), std::out_of_range);
CHECK_THROWS_AS(extract_value("Key", "a=1 Key= "), std::out_of_range);
}
TEST_CASE("utilities: the value of a key is read into a variable, or the default given when the key isn't there") {
int number{-1};
CHECK(extract_value(number, "Key", "a=1 Key=12", ""));
CHECK(number == 12);
CHECK_FALSE(extract_value(number, "Other", "a=1 Key=12", "7"));
CHECK(number == 7);
// no default leaves the variable as it is
CHECK_FALSE(extract_value(number, "Other", "a=1 Key=12", ""));
CHECK(number == 7);
double real{0.0};
CHECK(extract_value(real, "Key", "Key=2.5", ""));
CHECK(real == doctest::Approx(2.5));
// a flag is on only for a yes
bool flag{false};
CHECK(extract_value(flag, "Key", "Key=Yes", ""));
CHECK(flag);
CHECK(extract_value(flag, "Key", "Key=1", ""));
CHECK_FALSE(flag);
CHECK(extract_value(flag, "Key", "Key=true", ""));
CHECK_FALSE(flag);
CHECK_FALSE(extract_value(flag, "Other", "Key=no", "yes"));
CHECK(flag);
CHECK_FALSE(extract_value(flag, "Other", "Key=no", ""));
CHECK(flag);
}
TEST_CASE("utilities: a text has a hash which is the same on every system") {
// FNV-1a, 32 bits
CHECK(hash_string("") == 2166136261u);
CHECK(hash_string("a") == 0xE40C292Cu);
CHECK(hash_string("foobar") == 0xBF9CF968u);
CHECK(hash_string("EU07-005") == 1926712284u);
// the seed gives another one
CHECK(hash_string("", 5) == 2166136256u);
CHECK(hash_string("EU07-005", 42) == 1563400698u);
}
TEST_CASE("utilities: the common start of two texts is counted, and a text is looked for in another") {
CHECK(len_common_prefix("abcdef", "abcxyz") == 3);
CHECK(len_common_prefix("abc", "abc") == 3);
CHECK(len_common_prefix("abc", "ab") == 2);
CHECK(len_common_prefix("", "abc") == 0);
CHECK(len_common_prefix("xbc", "abc") == 0);
CHECK(contains("dynamic/pkp/eu07", "pkp"));
CHECK_FALSE(contains("dynamic/pkp/eu07", "PKP"));
CHECK(contains("abc", ""));
CHECK(contains("abc", 'c'));
CHECK_FALSE(contains("abc", 'd'));
}
// file names ----------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: the extension of a file name is cut off at its last dot") {
auto const erased{[](std::string Name) {
auto const removed{erase_extension(Name)};
return std::pair<bool, std::string>{removed, Name};
}};
CHECK(erased("file.mat") == std::pair<bool, std::string>{true, "file"});
CHECK(erased("a.b.c") == std::pair<bool, std::string>{true, "a.b"});
CHECK(erased("file.") == std::pair<bool, std::string>{true, "file"});
CHECK(erased("../file.mat") == std::pair<bool, std::string>{true, "../file"});
CHECK(erased("noext") == std::pair<bool, std::string>{false, "noext"});
CHECK(erased("") == std::pair<bool, std::string>{false, ""});
// the dots of the folder above aren't one
CHECK(erased("../file") == std::pair<bool, std::string>{false, "../file"});
CHECK(erased("textures/../x") == std::pair<bool, std::string>{false, "textures/../x"});
// nor is a dot the name starts with
CHECK(erased(".hidden") == std::pair<bool, std::string>{false, ".hidden"});
// a dot in the name of a folder is taken for one
CHECK(erased("dir.d/file") == std::pair<bool, std::string>{true, "dir"});
}
TEST_CASE("utilities: the slashes of a file name are turned and the leading ones removed") {
std::string name{"dynamic\\pkp\\eu07.mmd"};
replace_slashes(name);
CHECK(name == "dynamic/pkp/eu07.mmd");
std::string leading{"//textures/a.dds"};
erase_leading_slashes(leading);
CHECK(leading == "textures/a.dds");
std::string plain{"textures/a.dds"};
erase_leading_slashes(plain);
CHECK(plain == "textures/a.dds");
std::string only{"///"};
erase_leading_slashes(only);
CHECK(only.empty());
// only the forward ones
std::string backward{"\\textures"};
erase_leading_slashes(backward);
CHECK(backward == "\\textures");
}
TEST_CASE("utilities: the folder of a file name is the part up to its last slash, the slash included") {
CHECK(substr_path("dynamic/pkp/eu07.mmd") == "dynamic/pkp/");
CHECK(substr_path("/file") == "/");
CHECK(substr_path("file.t3d").empty());
CHECK(substr_path("").empty());
// a folder written the Windows way isn't found
CHECK(substr_path("dynamic\\eu07.mmd").empty());
}
TEST_CASE("utilities: a file is told to be there, and looked for among names and extensions") {
test::scratch_folder const folder{"utilities_files"};
folder.write("tex.png", "x");
folder.write("other.dds", "x");
auto const base{folder.path()};
CHECK(FileExists(base + "tex.png"));
CHECK_FALSE(FileExists(base + "tex.dds"));
// a folder is there as well
CHECK(FileExists(base));
// the first name which has a file with one of the extensions, the extensions tried in their order
auto const found{FileExists(std::vector<std::string>{base + "missing", base + "tex", base + "other"}, std::vector<std::string>{".dds", ".png"})};
CHECK(found.first == base + "tex");
CHECK(found.second == ".png");
auto const other{FileExists(std::vector<std::string>{base + "other", base + "tex"}, std::vector<std::string>{".png", ".dds"})};
CHECK(other.first == base + "other");
CHECK(other.second == ".dds");
auto const none{FileExists(std::vector<std::string>{base + "missing"}, std::vector<std::string>{".dds", ".png"})};
CHECK(none.first.empty());
CHECK(none.second.empty());
}
TEST_CASE("utilities: a file is found by its name in another case") {
test::scratch_folder const folder{"utilities_cased"};
auto const name{folder.write("Cased.TXT", "x")};
// named as it is, it's given back as it was named
CHECK(FileCased(name) == name);
// named in another case: the name it has on the disk where the case matters, the name given where it doesn't
auto const cased{FileCased(folder.path("cased.txt"))};
REQUIRE_FALSE(cased.empty());
CHECK(FileExists(cased));
CHECK(ToLower(std::filesystem::path{cased}.filename().string()) == "cased.txt");
// no such file in any case
CHECK(FileCased(folder.path("nothing.txt")).empty());
CHECK(FileCased("eu07_unit_test_no_such_file.xyz").empty());
}
TEST_CASE("utilities: a file is found in folders named in another case, the way the parser gives the names in lowercase") {
test::scratch_folder const folder{"utilities_cased_folders"};
folder.write("Scenery/Braniewo/rozklady/Os91121.txt", "x");
folder.write("Textures/Tabl/L101-2m.BMP", "x");
// every part of the path in lowercase: the file as it's on the disk where the case matters, the name given where it doesn't
auto const timetable{FileCased(folder.path("scenery/braniewo/rozklady/os91121.txt"))};
REQUIRE_FALSE(timetable.empty());
CHECK(std::filesystem::exists(timetable));
CHECK(ToLower(timetable) == ToLower(folder.path("Scenery/Braniewo/rozklady/Os91121.txt")));
CHECK(FileOnDisk(folder.path("scenery/braniewo/rozklady/os91121.txt")) == timetable);
// the folders written the Windows way as well
CHECK_FALSE(FileCased(folder.path() + "scenery\\braniewo\\rozklady\\os91121.txt").empty());
// a folder missing in any case
CHECK(FileCased(folder.path("scenery/nowhere/rozklady/os91121.txt")).empty());
CHECK(FileOnDisk(folder.path("scenery/nowhere/rozklady/os91121.txt")) == folder.path("scenery/nowhere/rozklady/os91121.txt"));
// among names and extensions: found in any case, given back as named, the name being the key of the banks
auto const texture{FileExists(std::vector<std::string>{folder.path("textures/tabl/l101-2m")}, std::vector<std::string>{".dds", ".bmp"})};
REQUIRE_FALSE(texture.first.empty());
CHECK(texture.first == folder.path("textures/tabl/l101-2m"));
CHECK(texture.second == ".bmp");
CHECK(std::filesystem::exists(FileOnDisk(texture.first + texture.second)));
// a file written after the folder was gone through is found as well
CHECK(FileCased(folder.path("textures/tabl/l7-2m.bmp")).empty());
folder.write("Textures/Tabl/L7-2m.bmp", "x");
auto const added{FileCased(folder.path("textures/tabl/l7-2m.bmp"))};
REQUIRE_FALSE(added.empty());
CHECK(std::filesystem::exists(added));
}
TEST_CASE("utilities: a terrain file is found in another case, by its text or by its binary file") {
test::scratch_folder const folder{"utilities_cased_terrain"};
folder.write("Scenery/L204/Teren/Woda_ter.txtf", "x");
folder.write("Scenery/Nmt/Gory_ter.btf", "x");
auto const scenery{folder.path("Scenery/")};
std::vector<std::string> const extensions{".txtf", ".btf"};
// the name as the parser gives it: the files are there under the name given back, which differs only in case
auto const text{FileStemOnDisk(scenery, "l204/teren/woda_ter", extensions)};
CHECK(ToLower(text) == "l204/teren/woda_ter");
CHECK(std::filesystem::exists(scenery + text + ".txtf"));
auto const binary{FileStemOnDisk(scenery, "nmt/gory_ter", extensions)};
CHECK(ToLower(binary) == "nmt/gory_ter");
CHECK(std::filesystem::exists(scenery + binary + ".btf"));
// neither file in any case: the name stays as given
CHECK(FileStemOnDisk(scenery, "nmt/nowhere_ter", extensions) == "nmt/nowhere_ter");
}
TEST_CASE("utilities: the time a file was changed is given, zero for a file which isn't there") {
test::scratch_folder const folder{"utilities_modified"};
auto const name{folder.write("fresh.txt", "x")};
auto const modified{last_modified(name)};
CHECK(modified != 0);
// written just now
CHECK(std::abs(std::difftime(std::time(nullptr), modified)) < 24.0 * 3600.0);
CHECK(last_modified(folder.path("nothing.txt")) == 0);
}
TEST_CASE("utilities: the folders of the user's settings and of the cache are named after the game") {
// where they are depends on the system and its environment; no folder at all without the variables
if (auto const config{user_config_path("eu07.ini")}; false == config.empty()) {
CHECK(config.filename().string() == "eu07.ini");
CHECK(config.parent_path().filename().string() == "MaSzyna");
}
if (auto const cache{user_cache_path("geoportal")}; false == cache.empty()) {
CHECK(cache.filename().string() == "geoportal");
#if defined(_WIN32)
CHECK(cache.parent_path().filename().string() == "cache");
CHECK(cache.parent_path().parent_path().filename().string() == "MaSzyna");
#else
CHECK(cache.parent_path().filename().string() == "MaSzyna");
#endif
}
#if defined(_WIN32)
CHECK(user_config_path("eu07.ini").empty() == (std::getenv("APPDATA") == nullptr));
CHECK(user_cache_path("x").empty() == (std::getenv("LOCALAPPDATA") == nullptr));
#else
CHECK(user_config_path("eu07.ini").empty() == (std::getenv("HOME") == nullptr));
#endif
}
// numbers -------------------------------------------------------------------------------------------------------------
TEST_CASE("utilities: the sign of a number, and a number rounded to a whole one") {
CHECK(sign(-2.5) == -1.0);
CHECK(sign(0.0) == 0.0);
CHECK(sign(3) == 1);
// the other one has no zero
CHECK(Sign(0.0) == 1.0);
CHECK(Sign(-0.1) == -1.0);
CHECK(sq(-3) == 9);
CHECK(Round(2.4) == 2);
CHECK(Round(2.5) == 3);
CHECK(Round(0.0) == 0);
// the negative ones are rounded up: half is added, then the fraction cut
CHECK(Round(-0.6) == 0);
CHECK(Round(-1.5) == -1);
CHECK(Round(-1.6) == -1);
CHECK(Round(-2.5) == -2);
}
TEST_CASE("utilities: a value is kept within bounds; inverted bounds give the upper one, as the old clamp did") {
CHECK(safe_clamp(5, 0, 3) == 3);
CHECK(safe_clamp(-1, 0, 3) == 0);
CHECK(safe_clamp(2, 0, 3) == 2);
CHECK(safe_clamp(2.0, 2.0, 2.0) == 2.0);
// inverted bounds: always the upper bound, whatever the value
CHECK(safe_clamp(5, 3, 0) == 0);
CHECK(safe_clamp(-1, 3, 0) == 0);
CHECK(safe_clamp(2.0, 3.0, 1.0) == 1.0);
// NaN as the old clamp had it: a NaN value stays NaN, a NaN bound doesn't clamp
auto const notanumber{std::numeric_limits<double>::quiet_NaN()};
CHECK(std::isnan(safe_clamp(notanumber, 0.0, 1.0)));
CHECK(safe_clamp(2.0, 0.0, notanumber) == 2.0);
CHECK(safe_clamp(-1.0, notanumber, 1.0) == -1.0);
// what the helper gives for arguments in the order and of the signs of two calls (these checks don't call
// them): the AI braking test, whose demand is the stronger of the two (negative) bounds, as up to 26.05.1
double const threshold{-0.45};
CHECK(safe_clamp(0.3, threshold * 1.01, threshold * 1.21) == doctest::Approx(threshold * 1.21));
CHECK(safe_clamp(-0.6, threshold * 1.01, threshold * 1.21) == doctest::Approx(threshold * 1.21));
// and the bump at a rail joint, 0 in place of the value as up to 26.05.1: the figure is capped from above
// only, and above 68% of the top speed it is negative
CHECK(safe_clamp(0.0, 160.0, 160.0 - (150.0 + 160.0 * 0.32)) == doctest::Approx(-41.2));
CHECK(safe_clamp(0.0, 4.0, -0.5) == -0.5);
CHECK(safe_clamp(0.0, 4.0, 5.0) == 4.0);
}
TEST_CASE("utilities: a value is wrapped into a range, as an angle into the full circle") {
CHECK(clamp_circular(370.0) == doctest::Approx(10.0));
CHECK(clamp_circular(-10.0) == doctest::Approx(350.0));
CHECK(clamp_circular(360.0) == doctest::Approx(0.0));
CHECK(clamp_circular(720.0) == doctest::Approx(0.0));
CHECK(clamp_circular(7, 3) == 1);
CHECK(clamp_circular(-1, 3) == 2);
CHECK(clamp_circular(3, 3) == 0);
}
TEST_CASE("utilities: a size is rounded down to a power of two within its limits") {
CHECK(clamp_power_of_two(100u) == 64u);
CHECK(clamp_power_of_two(1024u) == 1024u);
CHECK(clamp_power_of_two(0u) == 1u);
CHECK(clamp_power_of_two(20000u) == 16384u);
CHECK(clamp_power_of_two(40000u) == 16384u);
CHECK(clamp_power_of_two(100u, 128u, 8192u) == 128u);
CHECK(clamp_power_of_two(10000u, 128u, 8192u) == 8192u);
}
TEST_CASE("utilities: a value is rounded to a step, a whole number down to it") {
CHECK(quantize(0.12f, 0.05f) == doctest::Approx(0.10));
CHECK(quantize(1.3, 0.5) == doctest::Approx(1.5));
CHECK(quantize(-1.3, 0.5) == doctest::Approx(-1.5));
// the division of whole numbers drops the fraction before the rounding
CHECK(quantize(7u, 4u) == 4u);
CHECK(quantize(8u, 4u) == 8u);
}
TEST_CASE("utilities: the lower of two speed limits, -1 standing for none") {
CHECK(min_speed(30.0, 50.0) == 30.0);
CHECK(min_speed(-1.0, 50.0) == 50.0);
CHECK(min_speed(50.0, -1.0) == 50.0);
CHECK(min_speed(-1.0, -1.0) == -1.0);
CHECK(min_speed(0.0, 50.0) == 0.0);
}
TEST_CASE("utilities: a value between two others is eased in and out") {
CHECK(smoothInterpolate(0.0, 10.0, 0.0) == doctest::Approx(0.0));
CHECK(smoothInterpolate(0.0, 10.0, 0.25) == doctest::Approx(1.5625));
CHECK(smoothInterpolate(0.0, 10.0, 0.5) == doctest::Approx(5.0));
CHECK(smoothInterpolate(0.0, 10.0, 1.0) == doctest::Approx(10.0));
CHECK(smoothInterpolate(10.0, 0.0, 0.25) == doctest::Approx(8.4375));
// the factor isn't kept between 0 and 1
CHECK(smoothInterpolate(0.0, 10.0, 2.0) == doctest::Approx(-40.0));
}
TEST_CASE("utilities: two numbers are equal within a margin, exactly with none") {
CHECK(is_equal(1.0, 1.000001));
CHECK_FALSE(is_equal(1.0, 1.1));
CHECK(is_equal(1.0, 1.05, 0.1));
CHECK(is_equal(1.0, 1.0, 0.0));
CHECK_FALSE(is_equal(1.0, 1.000001, 0.0));
}
TEST_CASE("utilities: the point of a segment nearest to another point is given as a part of the segment") {
glm::dvec3 const start{0.0, 0.0, 0.0};
glm::dvec3 const end{10.0, 0.0, 0.0};
CHECK(nearest_segment_point(start, end, glm::dvec3{5.0, 3.0, 0.0}) == doctest::Approx(0.5));
CHECK(nearest_segment_point(start, end, glm::dvec3{2.5, -7.0, 1.0}) == doctest::Approx(0.25));
// past the ends it's the end
CHECK(nearest_segment_point(start, end, glm::dvec3{-4.0, 1.0, 0.0}) == 0.0);
CHECK(nearest_segment_point(start, end, glm::dvec3{14.0, 1.0, 0.0}) == 1.0);
}
TEST_CASE("utilities: points in a line make no triangle, and a set of points has a box around it") {
glm::dvec3 const a{0.0, 0.0, 0.0};
glm::dvec3 const b{1.0, 1.0, 1.0};
CHECK(degenerate(a, b, glm::dvec3{2.0, 2.0, 2.0}));
CHECK(degenerate(a, b, b));
CHECK_FALSE(degenerate(a, b, glm::dvec3{1.0, 0.0, 0.0}));
std::vector<glm::dvec3> points{{1.0, -2.0, 3.0}, {-4.0, 5.0, 0.5}, {0.0, 0.0, 9.0}};
glm::dvec3 low;
glm::dvec3 high;
bounding_box(low, high, std::begin(points), std::end(points));
CHECK(low.x == -4.0);
CHECK(low.y == -2.0);
CHECK(low.z == 0.5);
CHECK(high.x == 1.0);
CHECK(high.y == 5.0);
CHECK(high.z == 9.0);
}