Add tests for FunctionProcessor

scalar case by now

tests/CMakeLists.txt

@@ -47,6 +47,7 @@ add_executable (unit_tests
   test_ExecUntilBreakOrContinue.cpp
   test_FakeProcessor.cpp
   test_ForProcessor.cpp
+  test_FunctionProcessor.cpp
   test_FunctionTable.cpp
   test_IfProcessor.cpp
   test_IncDecExpressionProcessor.cpp

tests/test_FunctionProcessor.cpp

+#include <catch2/catch.hpp>
+
+#include <ASTNodeValueBuilder.hpp>
+
+#include <ASTBuilder.hpp>
+#include <ASTNodeDataTypeBuilder.hpp>
+
+#include <ASTNodeDeclarationToAffectationConverter.hpp>
+#include <ASTNodeTypeCleaner.hpp>
+
+#include <ASTNodeExpressionBuilder.hpp>
+
+#include <ASTNodeAffectationExpressionBuilder.hpp>
+
+#include <ASTSymbolTableBuilder.hpp>
+
+#include <ASTPrinter.hpp>
+
+#include <Demangle.hpp>
+
+#include <PEGGrammar.hpp>
+
+#include <sstream>
+
+#define CHECK_FUNCTION_EVALUATION_RESULT(data, variable_name, expected_value) \
+  {                                                                           \
+    string_input input{data, "test.pgs"};                                     \
+    auto ast = ASTBuilder::build(input);                                      \
+                                                                              \
+    ASTSymbolTableBuilder{*ast};                                              \
+    ASTNodeDataTypeBuilder{*ast};                                             \
+    ASTNodeValueBuilder{*ast};                                                \
+                                                                              \
+    ASTNodeDeclarationToAffectationConverter{*ast};                           \
+    ASTNodeTypeCleaner<language::declaration>{*ast};                          \
+    ASTNodeTypeCleaner<language::let_declaration>{*ast};                      \
+                                                                              \
+    ASTNodeExpressionBuilder{*ast};                                           \
+    ExecUntilBreakOrContinue 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);                                         \
+  }
+
+TEST_CASE("FunctionProcessor", "[language]")
+{
+  SECTION("Scalar functions")
+  {
+    SECTION("-> B")
+    {
+      SECTION("B -> B")
+      {
+        SECTION("from B")
+        {
+          std::string_view data = R"(
+let f : B -> B, b -> not b;
+B b = f(true);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from N")
+        {
+          std::string_view data = R"(
+let f : B -> B, b -> not b;
+N n = 2;
+B b = f(n);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from Z")
+        {
+          std::string_view data = R"(
+let f : B -> B, b -> not b;
+B b = f(0);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", true);
+        }
+
+        SECTION("from R")
+        {
+          std::string_view data = R"(
+let f : B -> B, b -> not b;
+B b = f(0.3);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+      }
+
+      SECTION("N -> B")
+      {
+        SECTION("from B")
+        {
+          std::string_view data = R"(
+let f : N -> B, n -> n > 2;
+B b = f(true);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from N")
+        {
+          std::string_view data = R"(
+let f : N -> B, n -> n > 2;
+N n = 3;
+B b = f(n);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", true);
+        }
+
+        SECTION("from Z")
+        {
+          std::string_view data = R"(
+let f : N -> B, (n) -> (n > 2);
+B b = f(2);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from R")
+        {
+          std::string_view data = R"(
+let f : N -> B, n -> n > 2;
+B b = f(2.3);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+      }
+
+      SECTION("Z -> B")
+      {
+        SECTION("from B")
+        {
+          std::string_view data = R"(
+let f : Z -> B, z -> z-3 >= 0;
+B b = f(true);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from N")
+        {
+          std::string_view data = R"(
+let f : Z -> B, z -> z-3 >= 0;
+N n = 3;
+B b = f(n);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", true);
+        }
+
+        SECTION("from Z")
+        {
+          std::string_view data = R"(
+let f : Z -> B, z -> (z-3 >= 0);
+B b = f(2);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from R")
+        {
+          std::string_view data = R"(
+let f : Z -> B, (z) -> z-3 > 0;
+B b = f(3.3);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+      }
+
+      SECTION("R -> B")
+      {
+        SECTION("from B")
+        {
+          std::string_view data = R"(
+let f : R -> B, x -> x*x < 4;
+B b = f(true);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", true);
+        }
+
+        SECTION("from N")
+        {
+          std::string_view data = R"(
+let f : R -> B, x -> x*x < 4;
+N n = 3;
+B b = f(n);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from Z")
+        {
+          std::string_view data = R"(
+let f : R -> B, x -> x*x < 4;
+B b = f(-2);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", false);
+        }
+
+        SECTION("from R")
+        {
+          std::string_view data = R"(
+let f : R -> B, x -> x*x < 4;
+B b = f(-1.3);
+)";
+          CHECK_FUNCTION_EVALUATION_RESULT(data, "b", true);
+        }
+      }
+    }
+
+    SECTION("-> N")
+    {
+      SECTION("from N*N")
+      {
+        std::string_view data = R"(
+let f : N*N -> N, (m,n) -> m*n;
+N n = f(2,4);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "n", 8ul);
+      }
+
+      SECTION("from Z*Z")
+      {
+        std::string_view data = R"(
+let f : Z*Z -> N, (p,q) -> p*q;
+N n = f(-2,-4);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "n", 8ul);
+      }
+    }
+
+    SECTION("-> Z")
+    {
+      SECTION("from N*N")
+      {
+        std::string_view data = R"(
+let f : N*N -> Z, (m,n) -> m*n;
+Z z = f(2,4);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "z", 8l);
+      }
+
+      SECTION("from Z*Z")
+      {
+        std::string_view data = R"(
+let f : Z*Z -> Z, (p,q) -> p*q;
+Z z = f(-2,4);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "z", -8l);
+      }
+
+      SECTION("from R*Z")
+      {
+        std::string_view data = R"(
+let f : R*Z -> Z, (p,q) -> p*q;
+Z z = f(-0.5,8);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "z", -4l);
+      }
+    }
+
+    SECTION("-> R")
+    {
+      SECTION("from N*R")
+      {
+        std::string_view data = R"(
+let f : N*R -> R, (n,x) -> n*x;
+R r = f(2,4.2);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "r", double{2ul * 4.2});
+      }
+
+      SECTION("from R")
+      {
+        std::string_view data = R"(
+let f : R -> R, x -> x*x-1;
+R r = f(4);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "r", double{15});
+      }
+
+      SECTION("from R using global variable")
+      {
+        std::string_view data = R"(
+R x0 = 3;
+let f : R -> R, x -> x-x0;
+R x = f(7.3);
+)";
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "x", double{7.3 - 3});
+      }
+    }
+  }
+}