Begin tests for ASTNodeBinaryOperatorExpressionBuilder

tests/CMakeLists.txt

@@ -8,6 +8,7 @@ add_executable (unit_tests
   test_ASTBuilder.cpp
   test_ASTDotPrinter.cpp
   test_ASTNodeAffectationExpressionBuilder.cpp
+  test_ASTNodeBinaryOperatorExpressionBuilder.cpp
   test_ASTNodeDataType.cpp
   test_ASTNodeDataTypeBuilder.cpp
   test_ASTNodeDataTypeChecker.cpp

tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp

+#include <catch2/catch.hpp>
+
+#include <ASTNodeValueBuilder.hpp>
+
+#include <ASTBuilder.hpp>
+#include <ASTNodeDataTypeBuilder.hpp>
+
+#include <ASTNodeDeclarationCleaner.hpp>
+#include <ASTNodeDeclarationToAffectationConverter.hpp>
+
+#include <ASTNodeExpressionBuilder.hpp>
+
+#include <ASTNodeUnaryOperatorExpressionBuilder.hpp>
+
+#include <ASTSymbolTableBuilder.hpp>
+
+#include <ASTPrinter.hpp>
+
+#include <Demangle.hpp>
+
+#include <PEGGrammar.hpp>
+
+#define CHECK_AST(data, expected_output)                                                            \
+  {                                                                                                 \
+    static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>);                  \
+    static_assert(std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view> or      \
+                  std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>);            \
+                                                                                                    \
+    string_input input{data, "test.pgs"};                                                           \
+    auto ast = ASTBuilder::build(input);                                                            \
+                                                                                                    \
+    ASTSymbolTableBuilder{*ast};                                                                    \
+    ASTNodeDataTypeBuilder{*ast};                                                                   \
+    ASTNodeValueBuilder{*ast};                                                                      \
+                                                                                                    \
+    ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
+    ASTNodeDeclarationCleaner{*ast};                                                                \
+                                                                                                    \
+    ASTNodeExpressionBuilder{*ast};                                                                 \
+                                                                                                    \
+    std::stringstream ast_output;                                                                   \
+    ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
+                                                                                                    \
+    REQUIRE(ast_output.str() == expected_output);                                                   \
+  }
+
+TEST_CASE("ASTNodeBinaryOperatorExpressionBuilder", "[language]")
+{
+  SECTION("multiply")
+  {
+    SECTION("B")
+    {
+      std::string_view data = R"(
+B b;
+b*true;
+false*b*true;
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, bool, bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::true_kw:FakeProcessor)
+ `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, bool, bool>)
+     +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, bool, bool>)
+     |   +-(language::false_kw:FakeProcessor)
+     |   `-(language::name:b:NameProcessor)
+     `-(language::true_kw:FakeProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("N")
+    {
+      std::string_view data = R"(
+N n;
+N m;
+n*m*n;
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, unsigned long, unsigned long>)
+     +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, unsigned long, unsigned long>)
+     |   +-(language::name:n:NameProcessor)
+     |   `-(language::name:m:NameProcessor)
+     `-(language::name:n:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("Z")
+    {
+      std::string_view data = R"(
+Z a;
+a*3*a;
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
+     +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
+     |   +-(language::name:a:NameProcessor)
+     |   `-(language::integer:3:FakeProcessor)
+     `-(language::name:a:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("R")
+    {
+      std::string_view data = R"(
+2.3*1.2*2*false;
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, bool>)
+     +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, long>)
+     |   +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, double>)
+     |   |   +-(language::real:2.3:FakeProcessor)
+     |   |   `-(language::real:1.2:FakeProcessor)
+     |   `-(language::integer:2:FakeProcessor)
+     `-(language::false_kw:FakeProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+  }
+
+  SECTION("Errors")
+  {
+    // SECTION("Invalid unary operator")
+    // {
+    //   auto ast = std::make_unique<ASTNode>();
+
+    //   REQUIRE_THROWS_WITH(ASTNodeUnaryOperatorExpressionBuilder{*ast}, "unexpected error: undefined unary operator");
+    // }
+
+    // SECTION("Invalid unary operator")
+    // {
+    //   auto ast = std::make_unique<ASTNode>();
+
+    //   REQUIRE_THROWS_WITH(ASTNodeUnaryOperatorExpressionBuilder{*ast}, "unexpected error: undefined unary operator");
+    // }
+
+    // SECTION("Invalid value type for unary minus")
+    // {
+    //   auto ast = std::make_unique<ASTNode>();
+    //   ast->id  = typeid(language::unary_minus);
+    //   ast->children.emplace_back(std::make_unique<ASTNode>());
+
+    //   REQUIRE_THROWS_WITH(ASTNodeUnaryOperatorExpressionBuilder{*ast}, "undefined value type for unary operator");
+    // }
+
+    // SECTION("Invalid value type for unary not")
+    // {
+    //   auto ast = std::make_unique<ASTNode>();
+    //   ast->id  = typeid(language::unary_not);
+    //   ast->children.emplace_back(std::make_unique<ASTNode>());
+
+    //   REQUIRE_THROWS_WITH(ASTNodeUnaryOperatorExpressionBuilder{*ast}, "undefined value type for unary operator");
+    // }
+
+    SECTION("Invalid data type for unary operator")
+    {
+      auto ast         = std::make_unique<ASTNode>();
+      ast->id          = typeid(language::unary_minus);
+      ast->m_data_type = ASTNodeDataType::int_t;
+      ast->children.emplace_back(std::make_unique<ASTNode>());
+
+      REQUIRE_THROWS_WITH(ASTNodeUnaryOperatorExpressionBuilder{*ast},
+                          "unexpected error: invalid operand type for unary operator");
+    }
+  }
+}