mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-21 07:24:57 +01:00
* 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.1d1f16411(#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;fa2ed089swapped 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 (since96f43e11and4d72d352), and the old clamp made that the headroom Vmax - (Vel + 0.32 Vmax), negative above 68% of the top speed, capped from above only;d464628aand03bfbb13kept 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 befored1f16411. 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>
796 lines
32 KiB
C++
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);
|
|
}
|