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

Adjust further code formatting

Browse Source
This commit is contained in:
Clang Format
2023-11-19 21:59:57 +01:00
committed by Jan
parent d5f881be04
commit c858695f0c
96 changed files with 4036 additions and 2241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

633
test/ObjLoadingTests/Parsing/Menu/Sequence/EventHandlerSetScopeSequencesTests.cpp
View File

@ -71,10 +71,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("fadein")),
SimpleParserValue::String(pos, new std::string("some_element")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("fadein")),
SimpleParserValue::String(pos, new std::string("some_element")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -89,10 +91,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("noScriptCommand")),
SimpleParserValue::String(pos, new std::string("some_element")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("noScriptCommand")),
SimpleParserValue::String(pos, new std::string("some_element")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -104,11 +108,13 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, true);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("uiScript")),
SimpleParserValue::Identifier(pos, new std::string("somethingUnknown")),
SimpleParserValue::String(pos, new std::string("anArgumentForTheUnknownScript")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("uiScript")),
SimpleParserValue::Identifier(pos, new std::string("somethingUnknown")),
SimpleParserValue::String(pos, new std::string("anArgumentForTheUnknownScript")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
REQUIRE(result);
@ -161,42 +167,60 @@ namespace test::parsing::menu::sequence::event_handler_set
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use fadeIn", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("fadeIn")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("fadeIn")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("fadeIn" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use fadeOut", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("fadeOut")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("fadeOut")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("fadeOut" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use show", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("show")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("show")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("show" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use hide", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("hide")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("hide")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("hide" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use showMenu", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("showMenu")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("showMenu")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("showMenu" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use hideMenu", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("hideMenu")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("hideMenu")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("hideMenu" "some_element" ; )");
}
@ -254,10 +278,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("setColor")),
SimpleParserValue::Identifier(TokenPos(), new std::string("backColor")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("setColor")),
SimpleParserValue::Identifier(TokenPos(), new std::string("backColor")),
SimpleParserValue::Character(pos, ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -268,50 +294,71 @@ namespace test::parsing::menu::sequence::event_handler_set
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use open", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("open")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("open")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("open" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use close", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("close")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("close")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("close" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use escape", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("escape")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("escape")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("escape" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use closeForAllPlayers", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("closeForAllPlayers")),
SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
R"("closeForAllPlayers" "some_element" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("closeForAllPlayers")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("closeForAllPlayers" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use ingameOpen", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("ingameOpen")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("ingameOpen")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("ingameOpen" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use ingameClose", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("ingameClose")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("ingameClose")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("ingameClose" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use setBackground", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("setBackground")),
SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
R"("setBackground" "some_element" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("setBackground")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("setBackground" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use setItemColor with forecolor", "[parsing][sequence][menu]")
@ -386,14 +433,20 @@ namespace test::parsing::menu::sequence::event_handler_set
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use setFocus", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("setFocus")), SimpleParserValue::String(TokenPos(), new std::string("some_element"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("setFocus")),
SimpleParserValue::String(TokenPos(), new std::string("some_element")),
},
R"("setFocus" "some_element" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use setFocusByDvar", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("setFocusByDvar")), SimpleParserValue::String(TokenPos(), new std::string("some_dvar"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("setFocusByDvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
},
R"("setFocusByDvar" "some_dvar" ; )");
}
@ -411,202 +464,305 @@ namespace test::parsing::menu::sequence::event_handler_set
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use exec", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("exec")), SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("exec")),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("exec" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execNow", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("execNow")), SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execNow")),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execNow" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execOnDvarStringValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execOnDvarStringValue" "some_dvar" "some_value" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execOnDvarStringValue" "some_dvar" "some_value" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execOnDvarIntValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execOnDvarIntValue" "some_dvar" "1" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execOnDvarIntValue" "some_dvar" "1" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execOnDvarFloatValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execOnDvarFloatValue" "some_dvar" "1" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execOnDvarFloatValue" "some_dvar" "1" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execNowOnDvarStringValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execNowOnDvarStringValue" "some_dvar" "some_value" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execNowOnDvarStringValue" "some_dvar" "some_value" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execNowOnDvarIntValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execNowOnDvarIntValue" "some_dvar" "1" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execNowOnDvarIntValue" "some_dvar" "1" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use execNowOnDvarFloatValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command"))},
R"("execNowOnDvarFloatValue" "some_dvar" "1" "some_command" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("execNowOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_command")),
},
R"("execNowOnDvarFloatValue" "some_dvar" "1" "some_command" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use play", "[parsing][sequence][menu]")
{
TestGenericScriptStatement(
{SimpleParserValue::Identifier(TokenPos(), new std::string("play")), SimpleParserValue::String(TokenPos(), new std::string("some_sound"))},
{
SimpleParserValue::Identifier(TokenPos(), new std::string("play")),
SimpleParserValue::String(TokenPos(), new std::string("some_sound")),
},
R"("play" "some_sound" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use scriptMenuResponse", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuResponse")),
SimpleParserValue::String(TokenPos(), new std::string("some_response"))},
R"("scriptMenuResponse" "some_response" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuResponse")),
SimpleParserValue::String(TokenPos(), new std::string("some_response")),
},
R"("scriptMenuResponse" "some_response" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use scriptMenuRespondOnDvarStringValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_response"))},
R"("scriptMenuRespondOnDvarStringValue" "some_dvar" "some_value" "some_response" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarStringValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::String(TokenPos(), new std::string("some_value")),
SimpleParserValue::String(TokenPos(), new std::string("some_response")),
},
R"("scriptMenuRespondOnDvarStringValue" "some_dvar" "some_value" "some_response" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use scriptMenuRespondOnDvarIntValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_response"))},
R"("scriptMenuRespondOnDvarIntValue" "some_dvar" "1" "some_response" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarIntValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_response")),
},
R"("scriptMenuRespondOnDvarIntValue" "some_dvar" "1" "some_response" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use scriptMenuRespondOnDvarFloatValue", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_response"))},
R"("scriptMenuRespondOnDvarFloatValue" "some_dvar" "1" "some_response" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("scriptMenuRespondOnDvarFloatValue")),
SimpleParserValue::String(TokenPos(), new std::string("some_dvar")),
SimpleParserValue::Integer(TokenPos(), 1),
SimpleParserValue::String(TokenPos(), new std::string("some_response")),
},
R"("scriptMenuRespondOnDvarFloatValue" "some_dvar" "1" "some_response" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use updateMail", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("updateMail"))}, R"("updateMail" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("updateMail")),
},
R"("updateMail" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use openMail", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("openMail"))}, R"("openMail" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("openMail")),
},
R"("openMail" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use deleteMail", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("deleteMail"))}, R"("deleteMail" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("deleteMail")),
},
R"("deleteMail" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use doMailLottery", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("doMailLottery"))}, R"("doMailLottery" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("doMailLottery")),
},
R"("doMailLottery" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use resetStatsConfirm", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("resetStatsConfirm"))}, R"("resetStatsConfirm" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("resetStatsConfirm")),
},
R"("resetStatsConfirm" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use resetStatsCancel", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("resetStatsCancel"))}, R"("resetStatsCancel" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("resetStatsCancel")),
},
R"("resetStatsCancel" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use setGameMode", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("setGameMode")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_mode"))},
R"("setGameMode" "some_game_mode" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("setGameMode")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_mode")),
},
R"("setGameMode" "some_game_mode" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use feederTop", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("feederTop"))}, R"("feederTop" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("feederTop")),
},
R"("feederTop" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use feederBottom", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("feederBottom"))}, R"("feederBottom" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("feederBottom")),
},
R"("feederBottom" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use showGamerCard", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("showGamerCard"))}, R"("showGamerCard" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("showGamerCard")),
},
R"("showGamerCard" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use openForGameType", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("openForGameType")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_type"))},
R"("openForGameType" "some_game_type" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("openForGameType")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_type")),
},
R"("openForGameType" "some_game_type" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use closeForGameType", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("closeForGameType")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_type"))},
R"("closeForGameType" "some_game_type" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("closeForGameType")),
SimpleParserValue::String(TokenPos(), new std::string("some_game_type")),
},
R"("closeForGameType" "some_game_type" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use kickPlayer", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("kickPlayer"))}, R"("kickPlayer" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("kickPlayer")),
},
R"("kickPlayer" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use getKickPlayerQuestion", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("getKickPlayerQuestion"))}, R"("getKickPlayerQuestion" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("getKickPlayerQuestion")),
},
R"("getKickPlayerQuestion" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use partyUpdateMissingMapPackDvar", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("partyUpdateMissingMapPackDvar"))},
R"("partyUpdateMissingMapPackDvar" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("partyUpdateMissingMapPackDvar")),
},
R"("partyUpdateMissingMapPackDvar" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use togglePlayerMute", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("togglePlayerMute"))}, R"("togglePlayerMute" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("togglePlayerMute")),
},
R"("togglePlayerMute" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use resolveError", "[parsing][sequence][menu]")
{
TestGenericScriptStatement({SimpleParserValue::Identifier(TokenPos(), new std::string("resolveError"))}, R"("resolveError" ; )");
TestGenericScriptStatement(
{
SimpleParserValue::Identifier(TokenPos(), new std::string("resolveError")),
},
R"("resolveError" ; )");
}
TEST_CASE("EventHandlerSetScopeSequences: Ensure can use lerp scale", "[parsing][sequence][menu]")
@ -745,15 +901,17 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarBool")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '%'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarBool")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '%'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
REQUIRE(result);
@ -778,15 +936,17 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarInt")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '*'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarInt")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '*'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
REQUIRE(result);
@ -811,15 +971,17 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarFloat")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '/'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarFloat")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '/'),
SimpleParserValue::Integer(TokenPos(), 2),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
REQUIRE(result);
@ -844,15 +1006,17 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarString")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '+'),
SimpleParserValue::String(TokenPos(), new std::string(" Hello")),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(TokenPos(), new std::string("setLocalVarString")),
SimpleParserValue::Identifier(TokenPos(), new std::string("sample_var")),
SimpleParserValue::Identifier(TokenPos(), new std::string("milliseconds")),
SimpleParserValue::Character(TokenPos(), '('),
SimpleParserValue::Character(TokenPos(), ')'),
SimpleParserValue::Character(TokenPos(), '+'),
SimpleParserValue::String(TokenPos(), new std::string(" Hello")),
SimpleParserValue::Character(TokenPos(), ';'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
REQUIRE(result);
@ -881,7 +1045,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -899,7 +1066,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
helper.m_state->m_current_script << R"("fadeIn" "some_element" ; )";
@ -925,14 +1095,16 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("if")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("if")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -969,12 +1141,14 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("if")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("if")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
helper.m_state->m_current_script << R"("fadeIn" "some_element" ; )";
@ -1006,15 +1180,17 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = currentIfCondition->m_condition_elements.get();
@ -1058,13 +1234,15 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = currentIfCondition->m_condition_elements.get();
@ -1100,13 +1278,15 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
}
@ -1115,13 +1295,15 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("elseif")),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition =
std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), std::make_unique<CommonEventHandlerSet>());
@ -1136,10 +1318,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = currentIfCondition->m_condition_elements.get();
@ -1166,10 +1350,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = currentIfCondition->m_condition_elements.get();
@ -1196,10 +1382,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
}
@ -1208,10 +1396,12 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::Identifier(pos, new std::string("else")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition =
std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), std::make_unique<CommonEventHandlerSet>());
@ -1226,7 +1416,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto currentIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = currentIfCondition->m_condition_elements.get();
@ -1248,7 +1441,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto baseIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = baseIfCondition->m_condition_elements.get();
@ -1274,7 +1470,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto baseIfCondition =
std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), std::make_unique<CommonEventHandlerSet>());
@ -1302,7 +1501,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto baseIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = baseIfCondition->m_condition_elements.get();
@ -1332,7 +1534,10 @@ namespace test::parsing::menu::sequence::event_handler_set
{
EventHandlerSetSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '}'), SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
const auto baseIfCondition = std::make_unique<CommonEventHandlerCondition>(nullptr, std::make_unique<CommonEventHandlerSet>(), nullptr);
helper.m_state->m_current_nested_event_handler_set = baseIfCondition->m_condition_elements.get();

26
test/ObjLoadingTests/Parsing/Menu/Sequence/ItemScopeSequencesTests.cpp
View File

@ -66,18 +66,20 @@ namespace test::parsing::menu::sequence::item
{
ItemSequenceTestsHelper helper(FeatureLevel::IW4, false);
const TokenPos pos;
helper.Tokens({SimpleParserValue::Identifier(pos, new std::string("dvarStrList")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::String(pos, new std::string("@MENU_AUTO")),
SimpleParserValue::String(pos, new std::string("auto")),
SimpleParserValue::String(pos, new std::string("@MENU_STANDARD_4_3")),
SimpleParserValue::String(pos, new std::string("standard")),
SimpleParserValue::String(pos, new std::string("@MENU_WIDE_16_10")),
SimpleParserValue::String(pos, new std::string("wide 16:10")),
SimpleParserValue::String(pos, new std::string("@MENU_WIDE_16_9")),
SimpleParserValue::String(pos, new std::string("wide 16:9")),
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Identifier(pos, new std::string("dvarStrList")),
SimpleParserValue::Character(pos, '{'),
SimpleParserValue::String(pos, new std::string("@MENU_AUTO")),
SimpleParserValue::String(pos, new std::string("auto")),
SimpleParserValue::String(pos, new std::string("@MENU_STANDARD_4_3")),
SimpleParserValue::String(pos, new std::string("standard")),
SimpleParserValue::String(pos, new std::string("@MENU_WIDE_16_10")),
SimpleParserValue::String(pos, new std::string("wide 16:10")),
SimpleParserValue::String(pos, new std::string("@MENU_WIDE_16_9")),
SimpleParserValue::String(pos, new std::string("wide 16:9")),
SimpleParserValue::Character(pos, '}'),
SimpleParserValue::EndOfFile(pos),
});
helper.m_item->m_feature_type = CommonItemFeatureType::MULTI_VALUE;
helper.m_item->m_multi_value_features = std::make_unique<CommonItemFeaturesMultiValue>();

359
test/ParserTests/Parsing/Simple/SimpleExpressionTests.cpp
View File

@ -59,7 +59,9 @@ namespace test::parsing::simple::expression
protected:
const std::vector<sequence_t*>& GetTestsForState() override
{
static std::vector<sequence_t*> tests({new SimpleExpressionSequence()});
static std::vector<sequence_t*> tests({
new SimpleExpressionSequence(),
});
return tests;
}
@ -140,10 +142,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -162,10 +166,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 428),
SimpleParserValue::Character(pos, '-'),
SimpleParserValue::Integer(pos, 8),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 428),
SimpleParserValue::Character(pos, '-'),
SimpleParserValue::Integer(pos, 8),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -184,10 +190,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 105),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 4),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 105),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 4),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -206,10 +214,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 561540),
SimpleParserValue::Character(pos, '/'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 561540),
SimpleParserValue::Character(pos, '/'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -228,10 +238,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 92673),
SimpleParserValue::Character(pos, '%'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 92673),
SimpleParserValue::Character(pos, '%'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -250,10 +262,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 0x7FFFFFF0),
SimpleParserValue::Character(pos, '&'),
SimpleParserValue::Integer(pos, 0x2AAAAAAA),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 0x7FFFFFF0),
SimpleParserValue::Character(pos, '&'),
SimpleParserValue::Integer(pos, 0x2AAAAAAA),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -272,10 +286,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 5),
SimpleParserValue::Character(pos, '|'),
SimpleParserValue::Integer(pos, 3),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 5),
SimpleParserValue::Character(pos, '|'),
SimpleParserValue::Integer(pos, 3),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -294,11 +310,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 105),
SimpleParserValue::MultiCharacter(
pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::SHIFT_LEFT)),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 105),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::SHIFT_LEFT)),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -317,11 +334,13 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 42784),
SimpleParserValue::MultiCharacter(
pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::SHIFT_RIGHT)),
SimpleParserValue::Integer(pos, 5),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 42784),
SimpleParserValue::MultiCharacter(pos,
SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::SHIFT_RIGHT)),
SimpleParserValue::Integer(pos, 5),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -340,10 +359,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, '>'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, '>'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -362,11 +383,13 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(
pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::GREATER_EQUAL_THAN)),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(
pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::GREATER_EQUAL_THAN)),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -385,10 +408,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, '<'),
SimpleParserValue::Integer(pos, 421),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, '<'),
SimpleParserValue::Integer(pos, 421),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -407,11 +432,13 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 420),
SimpleParserValue::MultiCharacter(
pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::LESS_EQUAL_THAN)),
SimpleParserValue::Integer(pos, 421),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::MultiCharacter(pos,
SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::LESS_EQUAL_THAN)),
SimpleParserValue::Integer(pos, 421),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -430,11 +457,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens(
{SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::EQUALS)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::EQUALS)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -453,11 +481,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens(
{SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::NOT_EQUAL)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::NOT_EQUAL)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -476,11 +505,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens(
{SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::AND)),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::AND)),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -499,11 +529,12 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens(
{SimpleParserValue::Integer(pos, 0),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::OR)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 0),
SimpleParserValue::MultiCharacter(pos, SimpleExpressionMatchers::MULTI_TOKEN_OFFSET_BINARY + static_cast<int>(SimpleBinaryOperationId::OR)),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -522,14 +553,16 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 100),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 4),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 25),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 220),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 100),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 4),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 25),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 220),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -548,14 +581,16 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 40),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 10),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 40),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 10),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -574,12 +609,14 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -598,12 +635,14 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -622,16 +661,18 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -650,16 +691,18 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -678,16 +721,18 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, -1),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, -1),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -706,16 +751,18 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 210),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 210),
SimpleParserValue::Character(pos, '*'),
SimpleParserValue::Integer(pos, 2),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Integer(pos, 1337),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();
@ -734,16 +781,18 @@ namespace test::parsing::simple::expression
{
SimpleExpressionTestsHelper helper;
const TokenPos pos;
helper.Tokens({SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::EndOfFile(pos)});
helper.Tokens({
SimpleParserValue::Integer(pos, 0),
SimpleParserValue::Character(pos, '?'),
SimpleParserValue::Integer(pos, 420),
SimpleParserValue::Character(pos, ':'),
SimpleParserValue::Character(pos, '('),
SimpleParserValue::Integer(pos, 1336),
SimpleParserValue::Character(pos, '+'),
SimpleParserValue::Integer(pos, 1),
SimpleParserValue::Character(pos, ')'),
SimpleParserValue::EndOfFile(pos),
});
const auto result = helper.PerformTest();

258
test/ZoneCodeGeneratorLibTests/Parsing/Commands/Sequence/SequenceActionTests.cpp
View File

@ -125,14 +125,16 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -147,15 +149,17 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -171,17 +175,19 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -198,19 +204,21 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("yeet_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("yeet_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -228,14 +236,16 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("unknown_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("unknown_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
REQUIRE(helper.m_test_struct->m_post_load_action == nullptr);
@ -245,19 +255,21 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("unknown_type_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Identifier(pos, new std::string("arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("another_arg_t")),
CommandsParserValue::Character(pos, ','),
CommandsParserValue::Identifier(pos, new std::string("unknown_type_t")),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
REQUIRE(helper.m_test_struct->m_post_load_action == nullptr);
@ -267,13 +279,15 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
REQUIRE(helper.m_test_struct->m_post_load_action == nullptr);
@ -283,13 +297,15 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
helper.m_state->SetInUse(helper.m_test_struct);
auto result = helper.PerformTest();
@ -305,17 +321,19 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("container_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("container_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -330,14 +348,16 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
helper.m_state->SetInUse(helper.m_test_struct2);
auto result = helper.PerformTest();
@ -353,17 +373,19 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("container_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("container_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_child")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
helper.m_state->SetInUse(helper.m_arg_struct2);
auto result = helper.PerformTest();
@ -379,17 +401,19 @@ namespace test::parsing::commands::sequence::sequence_action
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_test")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("set")),
CommandsParserValue::Identifier(pos, new std::string("action")),
CommandsParserValue::Identifier(pos, new std::string("test_struct_t")),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Character(pos, ':'),
CommandsParserValue::Identifier(pos, new std::string("m_test")),
CommandsParserValue::Identifier(pos, new std::string("TestMethod")),
CommandsParserValue::Character(pos, '('),
CommandsParserValue::Character(pos, ')'),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
REQUIRE(helper.m_test_struct->m_post_load_action == nullptr);

30
test/ZoneCodeGeneratorLibTests/Parsing/Commands/Sequence/SequenceArchitectureTests.cpp
View File

@ -41,10 +41,12 @@ namespace test::parsing::commands::sequence::sequence_architecture
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x86")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x86")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -57,10 +59,12 @@ namespace test::parsing::commands::sequence::sequence_architecture
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x86")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x86")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();
@ -73,10 +77,12 @@ namespace test::parsing::commands::sequence::sequence_architecture
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x1337")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("architecture")),
CommandsParserValue::Identifier(pos, new std::string("x1337")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
REQUIRE_THROWS_AS(helper.PerformTest(), ParsingException);
REQUIRE(helper.m_repository->GetArchitecture() == Architecture::UNKNOWN);

10
test/ZoneCodeGeneratorLibTests/Parsing/Commands/Sequence/SequenceGameTests.cpp
View File

@ -41,10 +41,12 @@ namespace test::parsing::commands::sequence::sequence_game
{
CommandsSequenceTestsHelper helper;
const TokenPos pos;
helper.Tokens({CommandsParserValue::Identifier(pos, new std::string("game")),
CommandsParserValue::Identifier(pos, new std::string("very_cool_game")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos)});
helper.Tokens({
CommandsParserValue::Identifier(pos, new std::string("game")),
CommandsParserValue::Identifier(pos, new std::string("very_cool_game")),
CommandsParserValue::Character(pos, ';'),
CommandsParserValue::EndOfFile(pos),
});
auto result = helper.PerformTest();

12
test/ZoneCodeGeneratorLibTests/Parsing/Header/Sequence/SequenceNamespaceTests.cpp
View File

@ -10,11 +10,13 @@ namespace test::parsing::header::sequence::sequence_namespace
TEST_CASE("SequenceNamespace: Ensure can parse simple namespace directive", "[parsing][parsingstream]")
{
const TokenPos pos;
const auto lexer =
std::make_unique<MockLexer<HeaderParserValue>>(MockLexer<HeaderParserValue>({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{')},
HeaderParserValue::EndOfFile(pos)));
const auto lexer = std::make_unique<MockLexer<HeaderParserValue>>(MockLexer<HeaderParserValue>(
{
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
},
HeaderParserValue::EndOfFile(pos)));
const auto packValueSupplier = std::make_unique<MockPackValueSupplier>();
const auto sequence = std::make_unique<SequenceNamespace>();

586
test/ZoneCodeGeneratorLibTests/Parsing/Matcher/MatcherTests.cpp
View File

@ -79,12 +79,18 @@ namespace test::parsing::matcher
{
MatchersTestsHelper test;
const TokenPos pos;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier(), create.Char('{')});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier(),
create.Char('{'),
});
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 3);
@ -94,12 +100,18 @@ namespace test::parsing::matcher
{
MatchersTestsHelper test;
const TokenPos pos;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier(), create.Char('+')});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier(),
create.Char('+'),
});
REQUIRE(!test.PerformTest());
}
@ -109,12 +121,16 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
auto callbackCalled = false;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
});
test.MatchCallback(
[&callbackCalled](sequence_result_t& result)
{
@ -130,9 +146,14 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
auto callbackCalled = false;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT), HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
});
test.MatchCallback(
[&callbackCalled](sequence_result_t& result)
{
@ -151,15 +172,19 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Or({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
})});
test.Matchers({
create.Or({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
}),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -169,10 +194,12 @@ namespace test::parsing::matcher
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 1);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("test_struct")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("test_struct")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -191,15 +218,19 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Or({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
})});
test.Matchers({
create.Or({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
}),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -217,14 +248,18 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.Loop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)), create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)});
test.Matchers({
create.Loop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -246,10 +281,15 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.Loop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)), create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)});
test.Matchers({
create.Loop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT), HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
REQUIRE(!test.PerformTest());
}
@ -262,10 +302,15 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.OptionalLoop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)});
test.Matchers({
create.OptionalLoop(create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE)),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT), HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 1);
@ -280,13 +325,17 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos),
});
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 2);
@ -301,14 +350,18 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos),
});
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 3);
@ -323,15 +376,19 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Optional(create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos),
});
REQUIRE(!test.PerformTest());
}
@ -346,19 +403,28 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Loop(create.Or({create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT), create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF)})),
create.Or({create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF), create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM)})});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Loop(create.Or({
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF),
})),
create.Or({
create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF),
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
}),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::TYPEDEF),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::TYPEDEF),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::TYPEDEF),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::TYPEDEF),
HeaderParserValue::Keyword(pos, HeaderParserValueType::ENUM),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -386,14 +452,23 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE), create.Label(LABEL_TEST)});
test.LabeledMatchers({create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT), create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT)},
LABEL_TEST);
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Label(LABEL_TEST),
});
test.LabeledMatchers(
{
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
},
LABEL_TEST);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -417,14 +492,24 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE), create.Label(LABEL_TEST)});
test.LabeledMatchers({create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT), create.Optional(create.Label(LABEL_TEST))}, LABEL_TEST);
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Label(LABEL_TEST),
});
test.LabeledMatchers(
{
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Optional(create.Label(LABEL_TEST)),
},
LABEL_TEST);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -448,13 +533,18 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE), create.Identifier().Capture(CAPTURE_NAMESPACE_NAME), create.Char('{')});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Identifier().Capture(CAPTURE_NAMESPACE_NAME),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -487,20 +577,26 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Or({create.And({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Identifier().Capture(CAPTURE_NAMESPACE_NAME),
}),
create.And({
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Identifier().Capture(CAPTURE_STRUCT_NAME),
})}),
create.Char('{')});
test.Matchers({
create.Or({
create.And({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Identifier().Capture(CAPTURE_NAMESPACE_NAME),
}),
create.And({
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Identifier().Capture(CAPTURE_STRUCT_NAME),
}),
}),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -520,10 +616,12 @@ namespace test::parsing::matcher
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 3);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("bye_struct")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("bye_struct")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
{
@ -553,16 +651,20 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Loop(create.Identifier().Capture(CAPTURE_NAMESPACE_NAME)),
create.Char('{')});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE).Tag(TAG_NAMESPACE),
create.Loop(create.Identifier().Capture(CAPTURE_NAMESPACE_NAME)),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Identifier(pos, new std::string("hello_universe")),
HeaderParserValue::Identifier(pos, new std::string("hello_everyone")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Identifier(pos, new std::string("hello_universe")),
HeaderParserValue::Identifier(pos, new std::string("hello_everyone")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -607,13 +709,23 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.And({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier()}).Tag(TAG_AND_GROUP).Capture(CAPTURE_AND_GROUP), create.Char('{')});
test.Matchers({
create
.And({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier(),
})
.Tag(TAG_AND_GROUP)
.Capture(CAPTURE_AND_GROUP),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -647,16 +759,25 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers(
{create.Loop(create.And({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier()})).Tag(TAG_LOOP_GROUP).Capture(CAPTURE_LOOP_GROUP),
create.Char('{')});
test.Matchers({
create
.Loop(create.And({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier(),
}))
.Tag(TAG_LOOP_GROUP)
.Capture(CAPTURE_LOOP_GROUP),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_universe")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("hello_universe")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -700,28 +821,45 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::STRUCT), create.Label(LABEL_TYPENAME).Capture(CAPTURE_TYPENAME), create.Char('{')});
test.LabeledMatchers({create.And({create.Identifier(), create.OptionalLoop(create.And({create.Char(':'), create.Char(':'), create.Identifier()}))})
.Transform(
[](HeaderMatcherFactory::token_list_t& values)
{
std::ostringstream str;
str << values[0].get().IdentifierValue();
test.Matchers({
create.Type(HeaderParserValueType::STRUCT),
create.Label(LABEL_TYPENAME).Capture(CAPTURE_TYPENAME),
create.Char('{'),
});
test.LabeledMatchers(
{
create
.And({
create.Identifier(),
create.OptionalLoop(create.And({
create.Char(':'),
create.Char(':'),
create.Identifier(),
})),
})
.Transform(
[](HeaderMatcherFactory::token_list_t& values)
{
std::ostringstream str;
str << values[0].get().IdentifierValue();
for (auto i = 3u; i < values.size(); i += 3)
str << "::" << values[i].get().IdentifierValue();
for (auto i = 3u; i < values.size(); i += 3)
str << "::" << values[i].get().IdentifierValue();
return HeaderParserValue::TypeName(values[0].get().GetPos(), new std::string(str.str()));
})},
LABEL_TYPENAME);
return HeaderParserValue::TypeName(values[0].get().GetPos(), new std::string(str.str()));
}),
},
LABEL_TYPENAME);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello")),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Identifier(pos, new std::string("world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello")),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Identifier(pos, new std::string("world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -752,30 +890,45 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::STRUCT), create.Label(LABEL_TYPENAME).Capture(CAPTURE_TYPENAME), create.Char('{')});
test.LabeledMatchers({create
.And({create.Identifier().Capture(CAPTURE_FIRST_TYPENAME_IDENTIFIER),
create.OptionalLoop(create.And({create.Char(':'), create.Char(':'), create.Identifier()}))})
.Transform(
[](HeaderMatcherFactory::token_list_t& values)
{
std::ostringstream str;
str << values[0].get().IdentifierValue();
test.Matchers({
create.Type(HeaderParserValueType::STRUCT),
create.Label(LABEL_TYPENAME).Capture(CAPTURE_TYPENAME),
create.Char('{'),
});
test.LabeledMatchers(
{
create
.And({
create.Identifier().Capture(CAPTURE_FIRST_TYPENAME_IDENTIFIER),
create.OptionalLoop(create.And({
create.Char(':'),
create.Char(':'),
create.Identifier(),
})),
})
.Transform(
[](HeaderMatcherFactory::token_list_t& values)
{
std::ostringstream str;
str << values[0].get().IdentifierValue();
for (auto i = 3u; i < values.size(); i += 3)
str << "::" << values[i].get().IdentifierValue();
for (auto i = 3u; i < values.size(); i += 3)
str << "::" << values[i].get().IdentifierValue();
return HeaderParserValue::TypeName(values[0].get().GetPos(), new std::string(str.str()));
})},
LABEL_TYPENAME);
return HeaderParserValue::TypeName(values[0].get().GetPos(), new std::string(str.str()));
}),
},
LABEL_TYPENAME);
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello")),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Identifier(pos, new std::string("world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello")),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Character(pos, ':'),
HeaderParserValue::Identifier(pos, new std::string("world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -812,22 +965,26 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::STRUCT),
create.Identifier()
.Capture(CAPTURE_NAME)
.Transform(
[](HeaderMatcherFactory::token_list_t& tokens)
{
auto str = tokens[0].get().IdentifierValue();
std::transform(str.begin(), str.end(), str.begin(), toupper);
return HeaderParserValue::Identifier(tokens[0].get().GetPos(), new std::string(std::move(str)));
}),
create.Char('{')});
test.Matchers({
create.Type(HeaderParserValueType::STRUCT),
create.Identifier()
.Capture(CAPTURE_NAME)
.Transform(
[](HeaderMatcherFactory::token_list_t& tokens)
{
auto str = tokens[0].get().IdentifierValue();
std::transform(str.begin(), str.end(), str.begin(), toupper);
return HeaderParserValue::Identifier(tokens[0].get().GetPos(), new std::string(std::move(str)));
}),
create.Char('{'),
});
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::STRUCT),
HeaderParserValue::Identifier(pos, new std::string("hello_world")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
test.MatchCallback(
[](sequence_result_t& result)
@ -852,12 +1009,18 @@ namespace test::parsing::matcher
{
MatchersTestsHelper test;
const TokenPos pos;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier(), create.Char('{').NoConsume()});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier(),
create.Char('{').NoConsume(),
});
REQUIRE(test.PerformTest());
REQUIRE(test.GetConsumedTokenCount() == 2);
@ -869,12 +1032,17 @@ namespace test::parsing::matcher
MatchersTestsHelper test;
const TokenPos pos;
test.Tokens({HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos)});
test.Tokens({
HeaderParserValue::Keyword(pos, HeaderParserValueType::NAMESPACE),
HeaderParserValue::Identifier(pos, new std::string("test_namespace")),
HeaderParserValue::Character(pos, '{'),
HeaderParserValue::Invalid(pos),
});
const auto create = test.Factory();
test.Matchers({create.Type(HeaderParserValueType::NAMESPACE), create.Identifier().NoConsume().Capture(CAPTURE_NAME)});
test.Matchers({
create.Type(HeaderParserValueType::NAMESPACE),
create.Identifier().NoConsume().Capture(CAPTURE_NAME),
});
test.MatchCallback(
[](sequence_result_t& result)
{