18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 22:34:58 +01:00
Files
maszyna/tests/unit/test_utilities.cpp
maj00r c5d14e93ac fix: whole-number bounds of Random() give a real number again (#416)
* fix: whole-number bounds of Random() give a real number again

ee3af0bf (#99, in 26.05.2) renamed RandomInt to an overload,
Random(int, int). The calls with whole-number bounds that expect a real
number in between took the overload and draw whole numbers since:

- wheel flats given with P0 happen to 1 vehicle in 101 (before: none),
  the random part of a flat is a whole number of millimetres;
- the chance of truck hunting is h/101 instead of h/100;
- the wind starts with a whole azimuth, speed and rates of change, and
  its direction changes in whole degrees per second;
- the tachometer below 5 km/h jumps to whole numbers.

The whole-number draw is RandomInt again, keeping the shared engine and
the swap of inverted bounds; the loading screen's trivia use it. Those
calls take the real Random() again, as up to 26.05.1.

* RandomInt: the comment says what it draws and why it has a name of its own

The comment put the bug on the overloading. It was in the calls that pass
whole-number bounds and expect a real number; the separate name keeps
them on Random(double, double).

* fix: RandomInt draws from the local engine, as up to 26.05.1 from one of its own

From the review of #416: ee3af0bf moved RandomInt from an engine of its own
(std::mt19937 seeded by std::random_device) to Global.random_engine, the
engine of the run's seed, and only the name was taken back here. Its one
caller draws the trivia of the loading screen, in init_modes, before a
network client gets the seed of the session in server_hello: the server's
engine was then one draw ahead of the client's, and with a fixed
randomseed the trivia was the same on every start. It is drawn from
Global.local_random_engine now, the engine of what one machine shows,
seeded from a true random source in init_modes before the loader is made.

The test of the same seed checks the shared engine with Random() and the
local one with RandomInt(); a new test checks that RandomInt() doesn't move
the engine of the run's seed.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-21 10:39:40 +01:00

834 lines
33 KiB
C++

#include "stdafx.h"
#include "doctest.h"
#include "scratch.h"
#include <cmath>
#include <limits>
#include "utilities/Globals.h"
#include "utilities/utilities.h"
#include <cmath>
#include <type_traits>
// 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{RandomInt(3, 7)};
CHECK(value >= 3);
CHECK(value <= 7);
seen.insert(value);
auto const swapped{RandomInt(7, 3)};
CHECK(swapped >= 3);
CHECK(swapped <= 7);
}
CHECK(seen.size() == 5);
CHECK(RandomInt(5, 5) == 5);
}
TEST_CASE("utilities: whole-number bounds still give a real number in between") {
// the wind, the wheel flats, the truck hunting and the tachometer draw with whole-number bounds
static_assert(std::is_same_v<decltype(Random(0, 4)), double>);
auto fractions{0};
for (auto draw{0}; draw < 50; ++draw) {
auto const value{Random(0, 4)};
CHECK(value >= 0.0);
CHECK(value <= 4.0);
if (value != std::floor(value)) {
++fractions;
}
}
CHECK(fractions > 0);
}
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<double> first;
Global.random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
first.push_back(Random(0.0, 1000000.0));
}
std::vector<double> second;
Global.random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
second.push_back(Random(0.0, 1000000.0));
}
CHECK(first == second);
std::vector<int> localfirst;
Global.local_random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
localfirst.push_back(RandomInt(0, 1000000));
}
std::vector<int> localsecond;
Global.local_random_engine.seed(42);
for (auto draw{0}; draw < 5; ++draw) {
localsecond.push_back(RandomInt(0, 1000000));
}
CHECK(localfirst == localsecond);
}
TEST_CASE("utilities: the whole numbers are drawn from the local engine, not from that of the run's seed") {
// the trivia of the loading screen is drawn before a network client gets the seed of the session
Global.random_engine.seed(5);
auto const first{Random()};
Global.random_engine.seed(5);
RandomInt(0, 9);
CHECK(Random() == first);
}
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);
}