18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 23:55:00 +01:00
Files
maszyna/tests/unit/test_parser.cpp
jerrrrycho 2f13f052f7 test: characterize the parser of the text files
The tokens, comments, quotes, parameters and include directives of cParser, its numbers and its place in the text, as they behave now, with the files of the tests made in a folder of the build (scratch.h). The helpers of utilities.h which read from a parser are here too.
2026-11-11 22:40:02 +01:00

896 lines
37 KiB
C++

#include "stdafx.h"
#include "doctest.h"
#include "scratch.h"
#include "scene/scenelayers.h"
#include "utilities/Globals.h"
#include "utilities/parser.h"
#include "utilities/utilities.h"
// the parser of the game's text files (utilities/parser.cpp), as it behaves now: what a token is, what the comments,
// the quotes and the include directives do to the tokens, how the texts turn into numbers, and what the parser tells
// of its place in the file. these record the behaviour for later changes of the parser, its oddities included; the
// ones which look like mistakes are listed in COVERAGE.md
namespace {
char const *const default_break{"\n\r\t ;"};
// the tokens left in the parser, joined with '|'
std::string rest(cParser &Parser, bool const ToLower = true, char const *Break = default_break) {
std::string joined;
for (auto token{Parser.getToken<std::string>(ToLower, Break)}; false == token.empty(); token = Parser.getToken<std::string>(ToLower, Break)) {
if (false == joined.empty()) {
joined += '|';
}
joined += token;
}
return joined;
}
// the tokens of a text
std::string tokens(std::string const &Text, bool const ToLower = true, char const *Break = default_break) {
cParser parser(Text, cParser::buffer_TEXT);
return rest(parser, ToLower, Break);
}
// puts the settings of the binary terrain back as they were
struct binary_terrain_settings {
bool state{Global.file_binary_terrain_state};
int skipped{Global.file_binary_terrain_skipped};
binary_terrain_settings() = default;
binary_terrain_settings(binary_terrain_settings const &) = delete;
binary_terrain_settings &operator=(binary_terrain_settings const &) = delete;
~binary_terrain_settings() {
Global.file_binary_terrain_state = state;
Global.file_binary_terrain_skipped = skipped;
}
};
} // namespace
// tokens --------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: tokens end at spaces, tabs, line ends and semicolons, and come in lower case unless asked otherwise") {
std::string const text{"Alpha\tBETA;gamma\r\nDelta ;; epsilon"};
CHECK(tokens(text) == "alpha|beta|gamma|delta|epsilon");
CHECK(tokens(text, false) == "Alpha|BETA|gamma|Delta|epsilon");
// commas, colons and brackets are a part of the token for the default separators
CHECK(tokens("pos: [1,2] end") == "pos:|[1,2]|end");
// only the letters of ascii are changed, the bytes of utf-8 and windows-1250 stay
CHECK(tokens("\xC5\x81\xC3\x93\x44\xC5\xB9 \xA3\xD3\x44\x8F") == "\xC5\x81\xC3\x93\x64\xC5\xB9|\xA3\xD3\x64\x8F");
}
TEST_CASE("parser: every token can be read with separators of its own") {
cParser parser("a,b c;d", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>(true, ",") == "a");
CHECK(parser.getToken<std::string>(true, " ") == "b");
CHECK(parser.getToken<std::string>() == "c");
CHECK(parser.getToken<std::string>() == "d");
CHECK(parser.getToken<std::string>().empty());
}
TEST_CASE("parser: with no separators the rest of the text is one token") {
// no separators given at all is taken as none
cParser parser("one two\nthree", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>(false, nullptr) == "one two\nthree");
CHECK(parser.Line() == 2);
CHECK(tokens("one two\nthree", true, "") == "one two\nthree");
}
TEST_CASE("parser: the end of the text shows as eof, and a read past it as a failure, the way a stream does it") {
SUBCASE("the text ends with a token") {
cParser parser("a b", cParser::buffer_TEXT);
CHECK(parser.ok());
CHECK_FALSE(parser.eof());
CHECK(parser.getToken<std::string>() == "a");
CHECK_FALSE(parser.eof());
// the last token is ended by the end of the text
CHECK(parser.getToken<std::string>() == "b");
CHECK(parser.eof());
CHECK(parser.ok());
CHECK(parser.getToken<std::string>().empty());
CHECK_FALSE(parser.ok());
}
SUBCASE("the text ends with a separator") {
cParser parser("a\n", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "a");
CHECK_FALSE(parser.eof());
CHECK(parser.getToken<std::string>().empty());
CHECK(parser.eof());
CHECK(parser.ok());
CHECK(parser.getToken<std::string>().empty());
CHECK_FALSE(parser.ok());
}
SUBCASE("an empty text fails with its first read") {
// the check for a byte order mark looks for more text after the empty first token
cParser parser("", cParser::buffer_TEXT);
CHECK(parser.ok());
CHECK(parser.getToken<std::string>().empty());
CHECK(parser.eof());
CHECK_FALSE(parser.ok());
}
}
TEST_CASE("parser: a byte order mark at the start of the text isn't a part of the first token") {
cParser parser("\xEF\xBB\xBF" "first second", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "first");
// the place of the token in the text is the one after the mark
CHECK(parser.TokenBegin() == 3);
CHECK(parser.TokenEnd() == 8);
CHECK(parser.getToken<std::string>() == "second");
// a mark alone on its line gives no token
CHECK(tokens("\xEF\xBB\xBF\nfirst") == "first");
// it's a mark only at the start
CHECK(tokens("a \xEF\xBB\xBF" "b") == "a|\xEF\xBB\xBF" "b");
}
// comments ------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: comments are left out, to the end of the line or of the block") {
cParser parser("one // rest of the line\ntwo /* a\nblock */ three", cParser::buffer_TEXT);
CHECK(rest(parser) == "one|two|three");
CHECK(parser.Line() == 3);
// a comment ends the token it touches, and the text after it is a token of its own
CHECK(tokens("abc//x\ndef") == "abc|def");
CHECK(tokens("ab/*x*/cd") == "ab|cd");
// a slash or a star alone is a character like any other
CHECK(tokens("1/2 a*b / *") == "1/2|a*b|/|*");
}
TEST_CASE("parser: the comments stay in the tokens when the parser is told not to skip them") {
cParser parser("a // b /* c */", cParser::buffer_TEXT);
parser.skipComments = false;
CHECK(rest(parser) == "a|//|b|/*|c|*/");
}
TEST_CASE("parser: a comment the text ends in leaves the parser failed, not just at the end") {
for (auto const *text : {"a /* never closed", "a // the last line"}) {
CAPTURE(text);
cParser parser(text, cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "a");
CHECK(parser.ok());
CHECK(parser.getToken<std::string>().empty());
CHECK(parser.eof());
CHECK_FALSE(parser.ok());
}
// with a line end after it, the parser is at the end like after a token
cParser parser("a // the last line\n", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "a");
CHECK(parser.getToken<std::string>().empty());
CHECK(parser.eof());
CHECK(parser.ok());
}
TEST_CASE("parser: other comment marks can be added") {
CHECK(tokens("a # note\nb -- c\nd") == "a|#|note|b|--|c|d");
cParser parser("a # note\nb -- c\nd", cParser::buffer_TEXT);
// also after the parser read something
CHECK(parser.getToken<std::string>() == "a");
parser.addCommentStyle("#", "\n");
parser.addCommentStyle("--", "\n");
CHECK(rest(parser) == "b|d");
SUBCASE("a comment without an end mark takes the rest of the text") {
cParser ending("keep these stop and nothing else", cParser::buffer_TEXT);
ending.addCommentStyle("stop", "");
CHECK(rest(ending) == "keep|these");
}
SUBCASE("a mark of letters is compared with the token as it's read, in lower case or not") {
cParser lower("a REM x\nb", cParser::buffer_TEXT);
lower.addCommentStyle("rem", "\n");
CHECK(rest(lower) == "a|b");
cParser cased("a REM x\nb", cParser::buffer_TEXT);
cased.addCommentStyle("rem", "\n");
CHECK(rest(cased, false) == "a|REM|x|b");
}
}
// quotes --------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: quotes make one token of the text between them, with its case and separators kept") {
CHECK(tokens("Name \"Two Words\" Tail") == "name|Two Words|tail");
CHECK(tokens("\"a;b\tc\" x") == "a;b\tc|x");
// the marks of a comment too
CHECK(tokens("\"http://host/path\" x") == "http://host/path|x");
// the quoted text is glued to what it touches
CHECK(tokens("Pre\"In Side\"Post next") == "preIn Sidepost|next");
// a backslash takes the next character as it is
CHECK(tokens("\"say \\\"hi\\\" \\\\ done\" x") == "say \"hi\" \\ done|x");
}
TEST_CASE("parser: empty quotes give no token") {
CHECK(tokens("\"\" after") == "after");
CHECK(tokens("x \"\" y") == "x|y");
}
TEST_CASE("parser: quotes left open take the rest of the text, and the parser fails") {
cParser parser("\"open ended", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "open ended");
CHECK(parser.eof());
CHECK_FALSE(parser.ok());
}
// place in the text ---------------------------------------------------------------------------------------------------
TEST_CASE("parser: the line is the one the reading got to, counted from 1") {
cParser parser("one\ntwo\n\n\nthree // note\nfour \"a\nb\" /* x\ny */ five", cParser::buffer_TEXT);
CHECK(parser.Line() == 1);
// the line end which ended the token is read already
CHECK(parser.getToken<std::string>() == "one");
CHECK(parser.Line() == 2);
CHECK(parser.getToken<std::string>() == "two");
CHECK(parser.Line() == 3);
CHECK(parser.getToken<std::string>() == "three");
CHECK(parser.Line() == 5);
CHECK(parser.getToken<std::string>() == "four");
CHECK(parser.Line() == 6);
// the lines inside of quotes and comments count too
CHECK(parser.getToken<std::string>() == "a\nb");
CHECK(parser.Line() == 7);
CHECK(parser.getToken<std::string>() == "five");
CHECK(parser.Line() == 8);
CHECK(parser.LineMain() == 8);
}
TEST_CASE("parser: a line ended the Windows way is counted at its line feed") {
cParser parser("one\r\ntwo", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "one");
// only the carriage return is read yet
CHECK(parser.Line() == 1);
CHECK(parser.getToken<std::string>() == "two");
CHECK(parser.Line() == 2);
}
TEST_CASE("parser: the place of the token last read is given as offsets into the text") {
cParser parser("ab cd", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "ab");
CHECK(parser.TokenBegin() == 0);
CHECK(parser.TokenEnd() == 2);
CHECK(parser.getToken<std::string>() == "cd");
CHECK(parser.TokenBegin() == 4);
CHECK(parser.TokenEnd() == 6);
SUBCASE("the quotes are a part of it") {
cParser quoted("\"x y\" z", cParser::buffer_TEXT);
CHECK(quoted.getToken<std::string>() == "x y");
CHECK(quoted.TokenBegin() == 0);
CHECK(quoted.TokenEnd() == 5);
}
SUBCASE("and so is a comment touching the token") {
cParser commented("ab//c\nd", cParser::buffer_TEXT);
CHECK(commented.getToken<std::string>() == "ab");
CHECK(commented.TokenBegin() == 0);
CHECK(commented.TokenEnd() == 6);
}
}
TEST_CASE("parser: the progress is the part of the text read, in percent") {
cParser parser("aaaa bbbb ", cParser::buffer_TEXT);
CHECK(parser.getProgress() == 0);
CHECK(parser.getToken<std::string>() == "aaaa");
CHECK(parser.getProgress() == 50);
CHECK(parser.getFullProgress() == 50);
// a text put in front of the rest takes its share of what is left
parser.injectString("cc dd eeee");
CHECK(parser.getFullProgress() == 50);
CHECK(parser.getToken<std::string>() == "cc");
CHECK(parser.getProgress() == 50);
CHECK(parser.getFullProgress() == 65);
// nothing to read is all read
CHECK(cParser("", cParser::buffer_TEXT).getProgress() == 100);
CHECK(cParser("", cParser::buffer_TEXT).getFullProgress() == 100);
}
TEST_CASE("parser: a text made by the program is named by the folder given with it, or not at all") {
CHECK(cParser("a", cParser::buffer_TEXT).Name().empty());
CHECK(cParser("a", cParser::buffer_TEXT, "scenery/").Name() == "scenery/");
CHECK_FALSE(cParser("a", cParser::buffer_TEXT).InLayerFile());
}
// values --------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: several tokens are read at once and taken one by one into variables of their types") {
cParser parser("1 2.5 -3 Word yes rest", cParser::buffer_TEXT);
REQUIRE(parser.getTokens(5));
CHECK(parser.peek() == "1");
int whole{0};
double real{0.0};
float single{0.f};
std::string word;
bool flag{false};
parser >> whole >> real >> single >> word >> flag;
CHECK(whole == 1);
CHECK(real == doctest::Approx(2.5));
CHECK(single == doctest::Approx(-3.0));
CHECK(word == "word");
CHECK(flag);
CHECK(parser.peek().empty());
// the tokens not asked for are still to be read
CHECK(parser.getToken<std::string>() == "rest");
}
TEST_CASE("parser: too few tokens are told, and the variables left without one keep their values") {
cParser parser("a b", cParser::buffer_TEXT);
CHECK_FALSE(parser.getTokens(3));
std::string first;
std::string second;
std::string third{"untouched"};
parser >> first >> second >> third;
CHECK(first == "a");
CHECK(second == "b");
CHECK(third == "untouched");
// the same for the other types
int whole{7};
bool flag{true};
parser >> whole >> flag;
CHECK(whole == 7);
CHECK(flag);
}
TEST_CASE("parser: the tokens are read in lower case by default, and as written when asked") {
cParser parser("Alpha Beta", cParser::buffer_TEXT);
REQUIRE(parser.getTokens(2, false));
std::string first;
std::string second;
parser >> first >> second;
CHECK(first == "Alpha");
CHECK(second == "Beta");
}
TEST_CASE("parser: whole numbers are read up to what isn't a part of one") {
cParser parser("42 -7 3.9 12abc", cParser::buffer_TEXT);
CHECK(parser.getToken<int>() == 42);
CHECK(parser.getToken<int>() == -7);
CHECK(parser.getToken<int>() == 3);
CHECK(parser.getToken<int>() == 12);
// nothing left to read is a zero
CHECK(parser.getToken<int>() == 0);
}
TEST_CASE("parser: numbers with a fraction take a point, an exponent and a sign, whatever the system's language") {
cParser parser("0.25 -1.5e3 .5 +2.5 7. 1,5", cParser::buffer_TEXT);
CHECK(parser.getToken<double>() == doctest::Approx(0.25));
CHECK(parser.getToken<double>() == doctest::Approx(-1500.0));
CHECK(parser.getToken<double>() == doctest::Approx(0.5));
CHECK(parser.getToken<double>() == doctest::Approx(2.5));
CHECK(parser.getToken<double>() == doctest::Approx(7.0));
// a comma isn't a decimal point: the number ends at it
CHECK(parser.getToken<double>() == doctest::Approx(1.0));
CHECK(cParser("1e-3", cParser::buffer_TEXT).getToken<float>() == doctest::Approx(0.001));
// a word is a zero
CHECK(cParser("word", cParser::buffer_TEXT).getToken<double>() == 0.0);
}
TEST_CASE("parser: true, yes and 1 are true, anything else is false") {
cParser parser("Yes TRUE 1 no 0 maybe", cParser::buffer_TEXT);
// read as a flag the token is put in lower case, whatever the caller asks for
CHECK(parser.getToken<bool>(false));
CHECK(parser.getToken<bool>(false));
CHECK(parser.getToken<bool>());
CHECK_FALSE(parser.getToken<bool>());
CHECK_FALSE(parser.getToken<bool>());
CHECK_FALSE(parser.getToken<bool>());
// nothing left to read is false
CHECK_FALSE(parser.getToken<bool>());
// a token read before with its case kept is compared as it is
cParser cased("Yes yes", cParser::buffer_TEXT);
REQUIRE(cased.getTokens(2, false));
bool first{true};
bool second{false};
cased >> first >> second;
CHECK_FALSE(first);
CHECK(second);
}
TEST_CASE("parser: three numbers are read as a vector, with commas and brackets as separators") {
cParser parser("[ 1, 2.5 ; -3 ] next", cParser::buffer_TEXT);
auto const vector{parser.getToken<glm::vec3>()};
CHECK(vector.x == doctest::Approx(1.0));
CHECK(vector.y == doctest::Approx(2.5));
CHECK(vector.z == doctest::Approx(-3.0));
// the closing bracket is left for the next read
CHECK(rest(parser) == "]|next");
}
TEST_CASE("parser: a token can be skipped, or compared with the one expected") {
cParser parser("alpha Beta gamma", cParser::buffer_TEXT);
CHECK(parser.expectToken("alpha"));
parser.ignoreToken();
CHECK(parser.expectToken("gamma"));
CHECK_FALSE(parser.expectToken("gamma"));
// the token is compared in lower case
CHECK_FALSE(cParser("Beta", cParser::buffer_TEXT).expectToken("Beta"));
CHECK(cParser("Beta", cParser::buffer_TEXT).expectToken("beta"));
}
// tokens waiting ------------------------------------------------------------------------------------------------------
TEST_CASE("parser: the tokens read and not taken are dropped by the next read") {
cParser parser("a b c d e", cParser::buffer_TEXT);
CHECK(parser.autoclear());
REQUIRE(parser.getTokens(2));
CHECK(parser.peek() == "a");
CHECK(parser.getToken<std::string>() == "c");
CHECK(parser.peek().empty());
}
TEST_CASE("parser: told to keep them, the next reads take the waiting tokens first") {
cParser parser("a b c d e", cParser::buffer_TEXT);
CHECK_FALSE(parser.autoclear(false).autoclear());
REQUIRE(parser.getTokens(2));
CHECK(parser.getToken<std::string>() == "a");
CHECK(parser.peek() == "b");
// one waits, so one more is read
REQUIRE(parser.getTokens(2));
std::string first;
std::string second;
parser >> first >> second;
CHECK(first == "b");
CHECK(second == "c");
CHECK(parser.getToken<std::string>() == "d");
}
TEST_CASE("parser: many waiting tokens are taken in their order") {
// enough of them for the queue to drop the ones taken on the way
std::string text;
for (auto number{0}; number < 200; ++number) {
text += std::to_string(number) + ' ';
}
cParser parser(text, cParser::buffer_TEXT);
parser.autoclear(false);
REQUIRE(parser.getTokens(200));
auto wrong{0};
for (auto number{0}; number < 200; ++number) {
auto value{-1};
parser >> value;
if (value != number) {
++wrong;
}
}
CHECK(wrong == 0);
CHECK(parser.peek().empty());
}
// parameters ----------------------------------------------------------------------------------------------------------
TEST_CASE("parser: (pN) in a token is replaced with the N-th parameter, or with none when there's no such one") {
std::string const text{"(p1) x(p2)y (p3) (P1) (p0) (p1)-(p2) (p1"};
std::vector<std::string> const parameters{"First", "Second"};
// the parameter is put in lower case with the token
cParser lower(text, cParser::buffer_TEXT, "", true, parameters);
CHECK(rest(lower) == "first|xsecondy|none|first|none|first-second|(p1");
// with the case kept, a capital P isn't a parameter
cParser cased(text, cParser::buffer_TEXT, "", true, parameters);
CHECK(rest(cased, false) == "First|xSecondy|none|(P1)|none|First-Second|(p1");
// without parameters nothing is replaced
CHECK(tokens("(p1) (p3)") == "(p1)|(p3)");
}
// text put in front ---------------------------------------------------------------------------------------------------
TEST_CASE("parser: a text given to the parser is read before the rest, the one given last first") {
cParser parser("m1 m2", cParser::buffer_TEXT);
parser.injectString("a b");
parser.injectString("x y");
// what to do with the tokens read and not taken is told to the texts given, too
parser.autoclear(false);
CHECK(rest(parser) == "x|y|a|b|m1|m2");
}
TEST_CASE("parser: the text after the token last read can be taken as it is and skipped") {
cParser parser("one two three four", cParser::buffer_TEXT);
// the first token is left to the parser
CHECK(parser.remainingText().empty());
CHECK(parser.getToken<std::string>() == "one");
CHECK(std::string{parser.remainingText()} == "two three four");
parser.skipText(4, 0, 3);
CHECK(std::string{parser.remainingText()} == "three four");
CHECK(parser.TokenBegin() == 5);
CHECK(parser.TokenEnd() == 8);
CHECK(parser.Line() == 1);
CHECK(parser.getToken<std::string>() == "three");
// the lines skipped are counted as the caller says, and the end of the text isn't passed
parser.skipText(1000, 2, 4);
CHECK(parser.Line() == 3);
CHECK(parser.TokenBegin() == 14);
CHECK(parser.TokenEnd() == 18);
CHECK(parser.remainingText().empty());
CHECK(parser.getToken<std::string>().empty());
}
TEST_CASE("parser: the text isn't given when the parser would change its tokens") {
SUBCASE("tokens wait to be taken") {
cParser parser("one two three", cParser::buffer_TEXT);
REQUIRE(parser.getTokens(2));
CHECK(parser.remainingText().empty());
}
SUBCASE("there are parameters to put in") {
cParser parser("one two three", cParser::buffer_TEXT, "", true, {"x"});
CHECK(parser.getToken<std::string>() == "one");
CHECK(parser.remainingText().empty());
}
SUBCASE("the comments aren't skipped") {
cParser parser("one two three", cParser::buffer_TEXT);
parser.skipComments = false;
CHECK(parser.getToken<std::string>() == "one");
CHECK(parser.remainingText().empty());
}
SUBCASE("there are other comment marks") {
cParser parser("one two three", cParser::buffer_TEXT);
parser.addCommentStyle("#", "\n");
CHECK(parser.getToken<std::string>() == "one");
CHECK(parser.remainingText().empty());
}
}
TEST_CASE("parser: the text after the token is the one of the text being read, a text put in front included") {
cParser parser("m1 m2", cParser::buffer_TEXT);
CHECK(parser.getToken<std::string>() == "m1");
CHECK(std::string{parser.remainingText()} == "m2");
parser.injectString("x y z");
// its first token is left to the parser, too
CHECK(parser.remainingText().empty());
CHECK(parser.getToken<std::string>() == "x");
CHECK(std::string{parser.remainingText()} == "y z");
parser.skipText(2, 0, 1);
CHECK(rest(parser) == "z|m2");
}
// files ---------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: a file is read from the folder given, whatever its line ends") {
test::scratch_folder const folder{"parser_file"};
folder.write("plain.txt", "Alpha beta\ngamma");
folder.write("windows.txt", "a 1\r\nb 2\r\n");
folder.write("marked.txt", "\xEF\xBB\xBF" "first second");
cParser parser("plain.txt", cParser::buffer_FILE, folder.path());
CHECK(parser.ok());
CHECK(parser.Line() == 1);
CHECK(parser.Name() == folder.path() + "plain.txt");
CHECK(parser.InLayerFile());
CHECK(rest(parser) == "alpha|beta|gamma");
cParser windows("windows.txt", cParser::buffer_FILE, folder.path());
CHECK(rest(windows) == "a|1|b|2");
cParser marked("marked.txt", cParser::buffer_FILE, folder.path());
CHECK(rest(marked) == "first|second");
// the folder can be a part of the name as well
cParser whole(folder.path("plain.txt"), cParser::buffer_FILE);
CHECK(whole.Name() == folder.path("plain.txt"));
CHECK(rest(whole) == "alpha|beta|gamma");
}
TEST_CASE("parser: a file named in another case than on the disk is found") {
test::scratch_folder const folder{"parser_case"};
folder.write("Mixed.TXT", "found");
cParser parser("mixed.txt", cParser::buffer_FILE, folder.path());
CHECK(parser.ok());
CHECK(rest(parser) == "found");
}
TEST_CASE("parser: a file which isn't there gives a failed parser with nothing to read") {
test::scratch_folder const folder{"parser_missing"};
cParser parser("nothing.txt", cParser::buffer_FILE, folder.path());
CHECK_FALSE(parser.ok());
// no line to be at
CHECK(parser.Line() == 0);
CHECK(parser.getProgress() == 100);
CHECK(parser.Name() == folder.path() + "nothing.txt");
CHECK(parser.getToken<std::string>().empty());
}
TEST_CASE("parser: an empty file is read, with nothing in it") {
test::scratch_folder const folder{"parser_empty"};
folder.write("empty.txt", "");
cParser parser("empty.txt", cParser::buffer_FILE, folder.path());
CHECK(parser.ok());
CHECK(parser.Line() == 1);
CHECK(parser.getProgress() == 100);
CHECK(parser.getToken<std::string>().empty());
}
TEST_CASE("parser: a folder given for a file has nothing to read") {
test::scratch_folder const folder{"parser_folder"};
std::filesystem::create_directories(folder.root() / "inner.txt");
// whether it opens at all depends on the system, so the state of the parser does too
cParser parser("inner.txt", cParser::buffer_FILE, folder.path());
CHECK(parser.getToken<std::string>().empty());
}
TEST_CASE("parser: the tokens of a file are counted, the ones of the files it includes too") {
test::scratch_folder const folder{"parser_count"};
folder.write("count.txt", "a b\nc // d e\n\"f g\" include extra.txt end\n");
folder.write("extra.txt", "x y");
folder.write("empty.txt", "");
CHECK(cParser::countTokens("count.txt", folder.path()) == 6);
CHECK(cParser::countTokens("empty.txt", folder.path()) == 0);
CHECK(cParser::countTokens("nothing.txt", folder.path()) == 0);
}
// includes ------------------------------------------------------------------------------------------------------------
TEST_CASE("parser: include puts the tokens of another file in place of the directive, with its parameters put in") {
test::scratch_folder const folder{"parser_include"};
folder.write("part.inc", "Body (p1) (p2) (p3)\n");
std::string const text{"start include PART.inc One Two end finish"};
cParser parser(text, cParser::buffer_TEXT, folder.path());
CHECK(parser.getToken<std::string>() == "start");
CHECK(parser.LineMain() == 1);
CHECK(parser.getToken<std::string>() == "body");
// the parser tells of the file it reads now
CHECK(parser.Name() == folder.path() + "part.inc");
CHECK(parser.Line() == 1);
CHECK(parser.LineMain() == -1);
CHECK_FALSE(parser.InLayerFile());
// the parameters are read as written, and put in lower case with the tokens they go into
CHECK(rest(parser) == "one|two|none|finish");
CHECK(parser.Name() == folder.path());
CHECK(parser.LineMain() == 1);
// with the case kept, the name of the file is as written, and found in its case on the disk
cParser cased(text, cParser::buffer_TEXT, folder.path());
CHECK(rest(cased, false) == "start|Body|One|Two|none|finish");
// a file included without parameters keeps its placeholders
cParser bare("include part.inc end", cParser::buffer_TEXT, folder.path());
CHECK(rest(bare) == "body|(p1)|(p2)|(p3)");
}
TEST_CASE("parser: an included file includes others, named from the folder of the first file, not from its own") {
test::scratch_folder const folder{"parser_nested"};
folder.write("outer.inc", "o1 include sub/inner.inc (p1) end o2");
folder.write("sub/inner.inc", "i1 (p1)");
folder.write("sub/a.inc", "a include b.inc end");
folder.write("sub/b.inc", "beside");
folder.write("b.inc", "root");
// a parameter can be passed on
cParser parser("m1 include outer.inc X end m2", cParser::buffer_TEXT, folder.path());
CHECK(rest(parser) == "m1|o1|i1|x|o2|m2");
cParser relative("include sub/a.inc end", cParser::buffer_TEXT, folder.path());
CHECK(rest(relative) == "a|root");
// the folders can be written the Windows way
cParser backslash("include sub\\inner.inc Y end", cParser::buffer_TEXT, folder.path());
CHECK(rest(backslash) == "i1|y");
}
TEST_CASE("parser: an include of a file which isn't there, or is empty, is passed over with its parameters") {
test::scratch_folder const folder{"parser_bad_include"};
folder.write("empty.inc", "");
cParser missing("a include nothing.inc 1 2 end b", cParser::buffer_TEXT, folder.path());
CHECK(rest(missing) == "a|b");
cParser empty("a include empty.inc 1 2 end b", cParser::buffer_TEXT, folder.path());
CHECK(rest(empty) == "a|b");
}
TEST_CASE("parser: include is a directive only in lower case and when the parser expands them") {
test::scratch_folder const folder{"parser_no_include"};
folder.write("part.inc", "body");
// read with its case kept, another spelling is a token like any other
cParser cased("Include part.inc end", cParser::buffer_TEXT, folder.path());
CHECK(rest(cased, false) == "Include|part.inc|end");
cParser lower("INCLUDE part.inc end", cParser::buffer_TEXT, folder.path());
CHECK(rest(lower) == "body");
cParser plain("include part.inc end", cParser::buffer_TEXT, folder.path());
plain.expandIncludes = false;
CHECK(rest(plain) == "include|part.inc|end");
}
TEST_CASE("parser: read line by line, a line starting with include is the directive") {
test::scratch_folder const folder{"parser_line_include"};
folder.write("macro.txt", "first (p1)\nsecond (p2)\n");
folder.write("main.txt", "head\ninclude macro.txt 5 6 end\ntail\n");
cParser parser("main.txt", cParser::buffer_FILE, folder.path());
CHECK(rest(parser, false, "\n\r") == "head|first 5|second 6|tail");
// also when the parser is told not to expand the directives
cParser plain("main.txt", cParser::buffer_FILE, folder.path());
plain.expandIncludes = false;
CHECK(rest(plain, false, "\n\r") == "head|first 5|second 6|tail");
// and any line starting with these letters is taken for one: this one for an include of the file "d"
cParser word("one\nincluded in price\ntwo", cParser::buffer_TEXT, folder.path());
CHECK(rest(word, false, "\n\r") == "one|two");
}
TEST_CASE("parser: an include can name several files to pick one from at random") {
test::scratch_folder const folder{"parser_random_include"};
folder.write("only.inc", "chosen");
folder.write("one.inc", "first");
folder.write("two.inc", "second");
std::vector<std::string> const none;
cParser single("include [ only.inc ] end tail", cParser::buffer_TEXT, folder.path(), true, none, true);
CHECK(rest(single) == "chosen|tail");
// a single name is still a single file
cParser plain("include only.inc end tail", cParser::buffer_TEXT, folder.path(), true, none, true);
CHECK(rest(plain) == "chosen|tail");
cParser either("include [ one.inc two.inc ] end tail", cParser::buffer_TEXT, folder.path(), true, none, true);
auto const picked{either.getToken<std::string>()};
CHECK((picked == "first" || picked == "second"));
CHECK(rest(either) == "tail");
// a parser not told to takes the bracket for the name of the file
cParser literal("include [ only.inc ] end tail", cParser::buffer_TEXT, folder.path());
CHECK(rest(literal) == "tail");
}
TEST_CASE("parser: with the traction left out, the includes of the files in a tr or tra folder are passed over") {
// no files needed: the directives are skipped up to their end
cParser parser("before include tr/wires.scm 1 2 end after include other/tra/x.scm end last", cParser::buffer_TEXT, "", false);
CHECK(rest(parser) == "before|after|last");
// the folder is told by the letters before the slash, so this one is taken for traction too
cParser centre("include centr/dworzec.scm end x", cParser::buffer_TEXT, "", false);
CHECK(rest(centre) == "x");
// the other files are read
test::scratch_folder const folder{"parser_traction"};
folder.write("tory.scm", "track");
folder.write("tr/siec.scm", "wires");
cParser without("include tory.scm end include tr/siec.scm end x", cParser::buffer_TEXT, folder.path(), false);
CHECK(rest(without) == "track|x");
cParser with("include tory.scm end include tr/siec.scm end x", cParser::buffer_TEXT, folder.path(), true);
CHECK(rest(with) == "track|wires|x");
}
TEST_CASE("parser: read line by line, a traction include passed over takes the lines up to the next end with it") {
// the directive is skipped in the text of the parser, though its end was on the line of the directive
cParser parser("include tr/wires.scm end\nfirst line\nsecond end\nthird line", cParser::buffer_TEXT, "", false);
CHECK(rest(parser, false, "\n\r") == "third line");
}
TEST_CASE("parser: the include of a terrain file is passed over while the binary terrain is in use") {
test::scratch_folder const folder{"parser_terrain"};
folder.write("map_ter.scm", "terrain");
std::string const text{"a include map_ter.scm 1 2 end b"};
binary_terrain_settings restored;
Global.file_binary_terrain_state = true;
Global.file_binary_terrain_skipped = 0;
cParser skipping(text, cParser::buffer_TEXT, folder.path());
CHECK(rest(skipping) == "a|b");
CHECK(Global.file_binary_terrain_skipped == 1);
Global.file_binary_terrain_state = false;
cParser reading(text, cParser::buffer_TEXT, folder.path());
CHECK(rest(reading) == "a|terrain|b");
CHECK(Global.file_binary_terrain_skipped == 1);
}
TEST_CASE("parser: for a scenery opened for editing the included files are told to the scenery layers") {
// the layers themselves are stubs in the tests (engine_stubs.cpp): the templates used are all they keep
test::scratch_folder const folder{"parser_layers"};
folder.write("main.scm", "include szablon_testowy.inc end include other.scm 7 end tail");
folder.write("szablon_testowy.inc", "p");
folder.write("other.scm", "o (p1)");
cParser parser("main.scm", cParser::buffer_FILE, folder.path());
parser.sceneryLayers = true;
CHECK(parser.InLayerFile());
// a template isn't a layer file, a scenery file is
CHECK(parser.getToken<std::string>() == "p");
CHECK_FALSE(parser.InLayerFile());
CHECK(scene::Layers.templates().count("szablon_testowy.inc") == 1);
CHECK(parser.getToken<std::string>() == "o");
CHECK(parser.InLayerFile());
CHECK(rest(parser) == "7|tail");
CHECK(parser.InLayerFile());
}
// what the helpers of utilities.h read with the parser -----------------------------------------------------------------
TEST_CASE("parser: a point is three numbers") {
cParser parser("1 2.5 -3 4", cParser::buffer_TEXT);
auto const point{LoadPoint(parser)};
CHECK(point.x == doctest::Approx(1.0));
CHECK(point.y == doctest::Approx(2.5));
CHECK(point.z == doctest::Approx(-3.0));
CHECK(parser.getToken<int>() == 4);
// the ones there's no number for are zero
cParser few("1 2.5", cParser::buffer_TEXT);
auto const flat{LoadPoint(few)};
CHECK(flat.x == doctest::Approx(1.0));
CHECK(flat.y == doctest::Approx(2.5));
CHECK(flat.z == 0.0);
}
TEST_CASE("parser: a set of names is a single one, or several in brackets") {
cParser single("Dir\\File.T3D next", cParser::buffer_TEXT);
// in lower case, with the slashes turned
CHECK(deserialize_set(single) == std::vector<std::string>{"dir/file.t3d"});
CHECK(single.getToken<std::string>() == "next");
cParser several("[ a B\\c d ] next", cParser::buffer_TEXT);
CHECK(deserialize_set(several) == std::vector<std::string>{"a", "b/c", "d"});
CHECK(several.getToken<std::string>() == "next");
// the brackets have to stand apart from the names
cParser touching("[a b] next", cParser::buffer_TEXT);
CHECK(deserialize_set(touching) == std::vector<std::string>{"[a"});
// a set left open ends with the text, nothing gives an empty one
cParser open("[ a b", cParser::buffer_TEXT);
CHECK(deserialize_set(open) == std::vector<std::string>{"a", "b"});
cParser nothing("", cParser::buffer_TEXT);
CHECK(deserialize_set(nothing).empty());
// the separators are the caller's
cParser commas("[,a,b,]", cParser::buffer_TEXT);
CHECK(deserialize_set(commas, ",") == std::vector<std::string>{"a", "b"});
}
TEST_CASE("parser: one name of a set is picked at random") {
cParser single("Dir\\File.T3D next", cParser::buffer_TEXT);
CHECK(deserialize_random_set(single) == "dir/file.t3d");
CHECK(single.getToken<std::string>() == "next");
cParser one("[ only ] next", cParser::buffer_TEXT);
CHECK(deserialize_random_set(one) == "only");
CHECK(one.getToken<std::string>() == "next");
// the whole set is read whichever is picked
cParser several("[ a b c ] next", cParser::buffer_TEXT);
auto const picked{deserialize_random_set(several)};
CHECK((picked == "a" || picked == "b" || picked == "c"));
CHECK(several.getToken<std::string>() == "next");
// a set inside of a set gives one of its names to the outer one
cParser nested("[ [ x ] ] next", cParser::buffer_TEXT);
CHECK(deserialize_random_set(nested) == "x");
CHECK(nested.getToken<std::string>() == "next");
// an empty set gives nothing
cParser empty("[ ] next", cParser::buffer_TEXT);
CHECK(deserialize_random_set(empty).empty());
CHECK(empty.getToken<std::string>() == "next");
}
TEST_CASE("parser: the same seed picks the same name of a set") {
std::string const text{"[ a b c d e f g h ]"};
Global.random_engine.seed(7);
cParser first(text, cParser::buffer_TEXT);
auto const picked{deserialize_random_set(first)};
Global.random_engine.seed(7);
cParser second(text, cParser::buffer_TEXT);
CHECK(deserialize_random_set(second) == picked);
}
TEST_CASE("parser: a map is read a line for a key and its value") {
cParser parser("alpha One\nbeta Two Words", cParser::buffer_TEXT);
std::map<std::string, std::string> map;
deserialize_map(map, parser);
CHECK(map.size() == 2);
// with the case kept, the value being the rest of the line
CHECK(map["alpha"] == "One");
CHECK(map["beta"] == "Two Words");
SUBCASE("the values are read as their type") {
cParser numbers("a 1.5\nb 2", cParser::buffer_TEXT);
std::map<std::string, double> values;
deserialize_map(values, numbers);
CHECK(values.size() == 2);
CHECK(values["a"] == doctest::Approx(1.5));
CHECK(values["b"] == doctest::Approx(2.0));
}
SUBCASE("a line end after the last line adds an empty key") {
cParser ended("alpha One\nbeta Two\n", cParser::buffer_TEXT);
std::map<std::string, std::string> entries;
deserialize_map(entries, ended);
CHECK(entries.size() == 3);
CHECK(entries.count("") == 1);
}
SUBCASE("and so does an empty text") {
cParser empty("", cParser::buffer_TEXT);
std::map<std::string, std::string> entries;
deserialize_map(entries, empty);
CHECK(entries.size() == 1);
CHECK(entries.count("") == 1);
}
SUBCASE("the carriage return of a line ended the Windows way stays in the value") {
cParser windows("alpha One\r\nbeta Two", cParser::buffer_TEXT);
std::map<std::string, std::string> entries;
deserialize_map(entries, windows);
CHECK(entries["alpha"] == "One\r");
CHECK(entries["beta"] == "Two");
}
}