From 0c4d733c0ea78ed15964a56c56ccb081d3d2b35c Mon Sep 17 00:00:00 2001 From: Stephane Del Pino <stephane.delpino44@gmail.com> Date: Wed, 7 Oct 2020 15:43:16 +0200 Subject: [PATCH] Add missing tests for AffectationToTupleProcessor --- tests/CMakeLists.txt | 1 + tests/test_AffectationToTupleProcessor.cpp | 165 +++++++++++++++++++++ 2 files changed, 166 insertions(+) create mode 100644 tests/test_AffectationToTupleProcessor.cpp diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 7cd1ed890..6796d69e4 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -8,6 +8,7 @@ add_executable (unit_tests test_main.cpp test_AffectationProcessor.cpp test_AffectationToStringProcessor.cpp + test_AffectationToTupleProcessor.cpp test_Array.cpp test_ArraySubscriptProcessor.cpp test_ArrayUtils.cpp diff --git a/tests/test_AffectationToTupleProcessor.cpp b/tests/test_AffectationToTupleProcessor.cpp new file mode 100644 index 000000000..b778fdeae --- /dev/null +++ b/tests/test_AffectationToTupleProcessor.cpp @@ -0,0 +1,165 @@ +#include <catch2/catch.hpp> + +#include <language/ast/ASTBuilder.hpp> +#include <language/ast/ASTNodeAffectationExpressionBuilder.hpp> +#include <language/ast/ASTNodeDataTypeBuilder.hpp> +#include <language/ast/ASTNodeDeclarationToAffectationConverter.hpp> +#include <language/ast/ASTNodeExpressionBuilder.hpp> +#include <language/ast/ASTNodeTypeCleaner.hpp> +#include <language/ast/ASTSymbolTableBuilder.hpp> +#include <language/utils/ASTPrinter.hpp> +#include <utils/Demangle.hpp> + +#include <pegtl/string_input.hpp> + +#include <sstream> + +#define CHECK_AFFECTATION_RESULT(data, variable_name, expected_value) \ + { \ + string_input input{data, "test.pgs"}; \ + auto ast = ASTBuilder::build(input); \ + \ + ASTSymbolTableBuilder{*ast}; \ + ASTNodeDataTypeBuilder{*ast}; \ + \ + ASTNodeDeclarationToAffectationConverter{*ast}; \ + ASTNodeTypeCleaner<language::var_declaration>{*ast}; \ + \ + ASTNodeExpressionBuilder{*ast}; \ + ExecutionPolicy exec_policy; \ + ast->execute(exec_policy); \ + \ + auto symbol_table = ast->m_symbol_table; \ + \ + using namespace TAO_PEGTL_NAMESPACE; \ + position use_position{internal::iterator{"fixture"}, "fixture"}; \ + use_position.byte = 10000; \ + auto [symbol, found] = symbol_table->find(variable_name, use_position); \ + \ + auto attributes = symbol->attributes(); \ + auto value = std::get<decltype(expected_value)>(attributes.value()); \ + \ + REQUIRE(value == expected_value); \ + } + +// clazy:excludeall=non-pod-global-static + +TEST_CASE("ASTAffectationToTupleProcessor", "[language]") +{ + SECTION("Affectations from value") + { + CHECK_AFFECTATION_RESULT(R"( +let s :(R); s = 2.; +)", + "s", (std::vector<double>{2.})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(R); s = 2; +)", + "s", (std::vector<double>{2})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(string); s = 2.; +)", + "s", (std::vector<std::string>{std::to_string(2.)})); + + const std::string x_string = []() -> std::string { + std::ostringstream os; + os << TinyVector<3, double>{1, 2, 3} << std::ends; + return os.str(); + }(); + + CHECK_AFFECTATION_RESULT(R"( +let x :R^3, x = (1,2,3); +let s :(string); s = x; +)", + "s", (std::vector<std::string>{x_string})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(R^1); s = 1.3; +)", + "s", (std::vector<TinyVector<1>>{TinyVector<1>{1.3}})); + } + + SECTION("Affectations from list") + { + CHECK_AFFECTATION_RESULT(R"( +let t :(R); t = (2.,3); +)", + "t", (std::vector<double>{2., 3})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(string); s = (2.,3); +)", + "s", (std::vector<std::string>{std::to_string(2.), std::to_string(3)})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(string); s = (2.,3,"foo"); +)", + "s", + (std::vector<std::string>{std::to_string(2.), std::to_string(3), std::string{"foo"}})); + + const std::string x_string = []() -> std::string { + std::ostringstream os; + os << TinyVector<2, double>{1, 2} << std::ends; + return os.str(); + }(); + + CHECK_AFFECTATION_RESULT(R"( +let x : R^2, x = (1,2); +let s : (string); s = (2.,3, x); +)", + "s", (std::vector<std::string>{std::to_string(2.), std::to_string(3), x_string})); + + CHECK_AFFECTATION_RESULT(R"( +let x : R^2, x = (1,2); +let t :(R^2); t = (x,0); +)", + "t", (std::vector<TinyVector<2>>{TinyVector<2>{1, 2}, TinyVector<2>{0, 0}})); + + CHECK_AFFECTATION_RESULT(R"( +let t :(R^2); t = ((1,2),0); +)", + "t", (std::vector<TinyVector<2>>{TinyVector<2>{1, 2}, TinyVector<2>{0, 0}})); + + CHECK_AFFECTATION_RESULT(R"( +let x : R^1, x = 1; +let t :(R^1); t = (x,2); +)", + "t", (std::vector<TinyVector<1>>{TinyVector<1>{1}, TinyVector<1>{2}})); + } + + SECTION("Affectations from tuple") + { + const std::string x_string = []() -> std::string { + std::ostringstream os; + os << TinyVector<3, double>{1, 2, 3} << std::ends; + return os.str(); + }(); + + CHECK_AFFECTATION_RESULT(R"( +let x :(R^3), x = ((1,2,3)); +let s :(string); s = x; +)", + "s", (std::vector<std::string>{x_string})); + + CHECK_AFFECTATION_RESULT(R"( +let x :(R), x = (1,2,3); +let s :(string); s = x; +)", + "s", + (std::vector<std::string>{std::to_string(1.), std::to_string(2.), std::to_string(3.)})); + + CHECK_AFFECTATION_RESULT(R"( +let n :(N), n = (1,2,3); +let t :(R); t = n; +)", + "t", (std::vector<double>{1, 2, 3})); + + CHECK_AFFECTATION_RESULT(R"( +let s :(N), s = (1,2,3); +let t :(N); t = s; +)", + "t", (std::vector<uint64_t>{1, 2, 3})); + } +} -- GitLab