INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-09 22:38:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move generic parser unit tests from zonecodegenerator to parsertests

Browse Source
This commit is contained in:
Jan
2021-11-25 15:17:30 +01:00
parent 4b2f001e7c
commit 887d14df54
4 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
test/ZoneCodeGeneratorLibTests/Parsing/Impl/CommentRemovingStreamProxyTests.cpp
View File

@ -1,226 +0,0 @@
#include <catch2/catch.hpp>
#include "Parsing/Impl/CommentRemovingStreamProxy.h"
#include "Parsing/Mock/MockParserLineStream.h"
namespace test::parsing::impl::comment_removing_stream_proxy
{
TEST_CASE("CommentRemovingStreamProxy: Ensure simple single line comment is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"// hello",
"prefix // test",
"t//est"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line == "prefix ");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line == "t");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("CommentRemovingStreamProxy: Ensure single line comment expands to next line on backslash", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"// hello\\",
"this should still be a comment",
"this should not be a comment anymore"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line == "this should not be a comment anymore");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("CommentRemovingStreamProxy: Ensure single line comment expands to next line on backslash and is repeatable", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"// hello\\",
"this should still be a comment \\",
"this as well",
"this not anymore"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 4);
REQUIRE(line.m_line == "this not anymore");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("CommentRemovingStreamProxy: Ensure backslash must be last character to expand single line comment to next line", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"// hello\\",
"this should still be a comment \\ ",
"this not anymore"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line == "this not anymore");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("CommentRemovingStreamProxy: Ensure simple multiline comment works on one line", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"hello/* hell*/ world",
"/*this should be a comment*/",
"Hello /*asdf*/",
"/*asdf*/World"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line == "hello world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line == "Hello ");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 4);
REQUIRE(line.m_line == "World");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("CommentRemovingStreamProxy: Ensure simple multiline comment works over multiple lines", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"hello/* hell",
" hell*/ world/*nope",
"notatall",
"hehe*/xd"
};
MockParserLineStream mockStream(lines);
CommentRemovingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(line.m_line == "hello");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(line.m_line == " world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(line.m_line.empty());
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 4);
REQUIRE(line.m_line == "xd");
}
REQUIRE(proxy.Eof());
}
}

473
test/ZoneCodeGeneratorLibTests/Parsing/Impl/DefinesStreamProxyTests.cpp
View File

@ -1,473 +0,0 @@
#include <catch2/catch.hpp>
#include "Parsing/Impl/DefinesStreamProxy.h"
#include "Parsing/Mock/MockParserLineStream.h"
namespace test::parsing::impl::defines_stream_proxy
{
void ExpectLine(IParserLineStream* stream, const int lineNumber, const std::string& value)
{
auto line = stream->NextLine();
REQUIRE(line.m_line_number == lineNumber);
REQUIRE(line.m_line == value);
}
TEST_CASE("DefinesStreamProxy: Ensure simple define and positive ifdef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef ASDF",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "Hello World");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure simple define and negative ifdef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef NONO",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure simple define and positive ifndef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifndef NONO",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "Hello World");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure simple define and negative ifndef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifndef ASDF",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure else is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef NONO",
"Hello World1",
"#else",
"Hello World2",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "Hello World2");
ExpectLine(&proxy, 6, "");
ExpectLine(&proxy, 7, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure nested ifdef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef ASDF",
"#ifdef NONO",
"Hello World1",
"#else",
"Hello World2",
"#endif",
"#else",
"#ifdef ASDF",
"Hello World3",
"#else",
"Hello World4",
"#endif",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "");
ExpectLine(&proxy, 6, "Hello World2");
ExpectLine(&proxy, 7, "");
ExpectLine(&proxy, 8, "");
ExpectLine(&proxy, 9, "");
ExpectLine(&proxy, 10, "");
ExpectLine(&proxy, 11, "");
ExpectLine(&proxy, 12, "");
ExpectLine(&proxy, 13, "");
ExpectLine(&proxy, 14, "");
ExpectLine(&proxy, 15, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure undef is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef ASDF",
"Hello World",
"#endif",
"#undef ASDF",
"#ifdef ASDF",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "Hello World");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "");
ExpectLine(&proxy, 6, "");
ExpectLine(&proxy, 7, "");
ExpectLine(&proxy, 8, "");
ExpectLine(&proxy, 9, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure undef does not undefine everything", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF",
"#ifdef ASDF",
"Hello World",
"#endif",
"#undef NONO",
"#ifdef ASDF",
"Hello World",
"#endif",
"Hello Galaxy"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "Hello World");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "");
ExpectLine(&proxy, 6, "");
ExpectLine(&proxy, 7, "Hello World");
ExpectLine(&proxy, 8, "");
ExpectLine(&proxy, 9, "Hello Galaxy");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure simple defines are working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF LOL",
"ASDF",
"A ASDF B",
"ASDF B",
"A ASDF"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "LOL");
ExpectLine(&proxy, 3, "A LOL B");
ExpectLine(&proxy, 4, "LOL B");
ExpectLine(&proxy, 5, "A LOL");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure defines can be surrounded by symbols", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define ASDF LOL",
"!ASDF%"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "!LOL%");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can use multiple defines in one line", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define A Hello",
"#define B world",
"A my dear B!"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "Hello my dear world!");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure defines in disabled block are ignored", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#ifdef LOLO",
"#define hello world",
"#endif",
"hello"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "hello");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure undefs in disabled block are ignored", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define hello world",
"#ifdef LOLO",
"#undef hello",
"#endif",
"hello"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "");
ExpectLine(&proxy, 3, "");
ExpectLine(&proxy, 4, "");
ExpectLine(&proxy, 5, "world");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can define name with underscores and digits", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define __int16 short",
"unsigned __int16 value;"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "unsigned short value;");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure define can render parameters", "[parsing][parsingstream]")
{
DefinesStreamProxy::Define define("helloworld", "hello universe");
std::vector<std::string> parameterNames({
"universe"
});
define.IdentifyParameters(parameterNames);
std::vector<std::string> parameterValues({
"mr moneyman"
});
REQUIRE(define.Render(parameterValues) == "hello mr moneyman");
}
TEST_CASE("DefinesStreamProxy: Ensure define can render parameters in middle of symbols", "[parsing][parsingstream]")
{
DefinesStreamProxy::Define define("helloworld", "alignas(x)");
std::vector<std::string> parameterNames({
"x"
});
define.IdentifyParameters(parameterNames);
std::vector<std::string> parameterValues({
"1337"
});
REQUIRE(define.Render(parameterValues) == "alignas(1337)");
}
TEST_CASE("DefinesStreamProxy: Ensure can add define with parameters", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define test(x) alignas(x)",
"struct test(1337) test_struct"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "struct alignas(1337) test_struct");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can use parameter multiple times", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define test(x) x|x|x|x",
"struct test(1337) test_struct"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "struct 1337|1337|1337|1337 test_struct");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can use parameterized define in between symbols", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define test(x) x|x|x|x",
"%test(5)%"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "%5|5|5|5%");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can define multiple parameters", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define test(a1, a2, a3) a1 + a2 = a3",
"make calc test(1, 2, 3);"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "make calc 1 + 2 = 3;");
REQUIRE(proxy.Eof());
}
TEST_CASE("DefinesStreamProxy: Ensure can define multiple parameters without spacing", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"#define test(a1,a2,a3) a1+a2=a3",
"make calc test(1,2,3);"
};
MockParserLineStream mockStream(lines);
DefinesStreamProxy proxy(&mockStream);
ExpectLine(&proxy, 1, "");
ExpectLine(&proxy, 2, "make calc 1+2=3;");
REQUIRE(proxy.Eof());
}
}

181
test/ZoneCodeGeneratorLibTests/Parsing/Impl/IncludingStreamProxyTests.cpp
View File

@ -1,181 +0,0 @@
#include <catch2/catch.hpp>
#include "Parsing/Impl/IncludingStreamProxy.h"
#include "Parsing/Mock/MockParserLineStream.h"
namespace test::parsing::impl::including_stream_proxy
{
TEST_CASE("IncludingStreamProxy: Ensure simple include is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"Hello world",
"#include \"ASDF.txt\"",
"and bye"
};
const std::vector<std::string> asdf
{
"Hello galaxy"
};
MockParserLineStream mockStream(lines);
mockStream.AddIncludeLines("ASDF.txt", asdf);
IncludingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "Hello world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == "ASDF.txt");
REQUIRE(line.m_line == "Hello galaxy");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "and bye");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("IncludingStreamProxy: Ensure simple include with angle brackets is working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"Hello world",
"#include <ASDF.txt>",
"and bye"
};
const std::vector<std::string> asdf
{
"Hello galaxy"
};
MockParserLineStream mockStream(lines);
mockStream.AddIncludeLines("ASDF.txt", asdf);
IncludingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "Hello world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == "ASDF.txt");
REQUIRE(line.m_line == "Hello galaxy");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "and bye");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("IncludingStreamProxy: Ensure can have spaces before include directive", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"Hello world",
" #include \"ASDF.txt\" ",
"and bye"
};
const std::vector<std::string> asdf
{
"Hello galaxy"
};
MockParserLineStream mockStream(lines);
mockStream.AddIncludeLines("ASDF.txt", asdf);
IncludingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "Hello world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == "ASDF.txt");
REQUIRE(line.m_line == "Hello galaxy");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 3);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "and bye");
}
REQUIRE(proxy.Eof());
}
TEST_CASE("IncludingStreamProxy: Ensure pragma once prevents including the same file more than once", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"Hello world",
"#include \"ASDF.txt\"",
"#include \"ASDF.txt\"",
"and bye"
};
const std::vector<std::string> asdf
{
"#pragma once",
"Hello galaxy"
};
MockParserLineStream mockStream(lines);
mockStream.AddIncludeLines("ASDF.txt", asdf);
IncludingStreamProxy proxy(&mockStream);
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 1);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "Hello world");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 2);
REQUIRE(*line.m_filename == "ASDF.txt");
REQUIRE(line.m_line == "Hello galaxy");
}
{
auto line = proxy.NextLine();
REQUIRE(line.m_line_number == 4);
REQUIRE(*line.m_filename == MockParserLineStream::MOCK_FILENAME);
REQUIRE(line.m_line == "and bye");
}
REQUIRE(proxy.Eof());
}
}

39
test/ZoneCodeGeneratorLibTests/Parsing/Impl/PackDefinitionStreamProxyTests.cpp
View File

@ -1,39 +0,0 @@
#include <catch2/catch.hpp>
#include "Parsing/Impl/PackDefinitionStreamProxy.h"
#include "Parsing/Mock/MockParserLineStream.h"
namespace test::parsing::impl::pack_definition_stream_proxy
{
void ExpectLine(IParserLineStream* stream, const int lineNumber, const std::string& value)
{
auto line = stream->NextLine();
REQUIRE(line.m_line_number == lineNumber);
REQUIRE(line.m_line == value);
}
TEST_CASE("PackDefinitionStreamProxy: Ensure simple pack directives are working", "[parsing][parsingstream]")
{
const std::vector<std::string> lines
{
"hello world",
"#pragma pack(push, 32)",
"hello galaxy",
"#pragma pack(pop)",
"hello universe"
};
MockParserLineStream mockStream(lines);
PackDefinitionStreamProxy proxy(&mockStream);
REQUIRE(proxy.GetCurrentPack() == PackDefinitionStreamProxy::DEFAULT_PACK);
ExpectLine(&proxy, 1, "hello world");
REQUIRE(proxy.GetCurrentPack() == PackDefinitionStreamProxy::DEFAULT_PACK);
ExpectLine(&proxy, 3, "hello galaxy");
REQUIRE(proxy.GetCurrentPack() == 32);
ExpectLine(&proxy, 5, "hello universe");
REQUIRE(proxy.GetCurrentPack() == PackDefinitionStreamProxy::DEFAULT_PACK);
REQUIRE(proxy.Eof());
}
}