Add missing tests for ASTNodeFunctionExpressionBuilder

tests/test_ASTNodeFunctionExpressionBuilder.cpp

@@ -61,6 +61,25 @@
     REQUIRE_THROWS_AS(ASTNodeExpressionBuilder{*ast}, parse_error);                \
   }
 
+#define CHECK_AST_THROWS_WITH(data, error)                                         \
+  {                                                                                \
+    static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>); \
+    static_assert(std::is_same_v<std::decay_t<decltype(error)>, std::string>);     \
+                                                                                   \
+    string_input input{data, "test.pgs"};                                          \
+    auto ast = ASTBuilder::build(input);                                           \
+                                                                                   \
+    ASTModulesImporter{*ast};                                                      \
+    ASTNodeTypeCleaner<language::import_instruction>{*ast};                        \
+                                                                                   \
+    ASTSymbolTableBuilder{*ast};                                                   \
+    ASTNodeDataTypeBuilder{*ast};                                                  \
+                                                                                   \
+    ASTNodeTypeCleaner<language::declaration>{*ast};                               \
+    ASTNodeTypeCleaner<language::let_declaration>{*ast};                           \
+    REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, error);                    \
+  }
+
 TEST_CASE("ASTNodeFunctionExpressionBuilder", "[language]")
 {
   SECTION("return a B")
@@ -266,6 +285,106 @@ times_2_3(-2);
     }
   }
 
+  SECTION("return a string")
+  {
+    SECTION("string argument")
+    {
+      std::string_view data = R"(
+let cat : string*string -> string, (s1,s2) -> s1+s2;
+cat("foo", "bar");
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:cat:NameProcessor)
+     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
+         +-(language::literal:"foo":ValueProcessor)
+         `-(language::literal:"bar":ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("B argument conversion")
+    {
+      std::string_view data = R"(
+let cat : string*string -> string, (s1,s2) -> s1+s2;
+cat("foo", true);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:cat:NameProcessor)
+     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
+         +-(language::literal:"foo":ValueProcessor)
+         `-(language::true_kw:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("N argument conversion")
+    {
+      std::string_view data = R"(
+let cat : string*string -> string, (s1,s2) -> s1+s2;
+N n = 2;
+cat("foo", n);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:cat:NameProcessor)
+     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
+         +-(language::literal:"foo":ValueProcessor)
+         `-(language::name:n:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("Z argument conversion")
+    {
+      std::string_view data = R"(
+let cat : string*string -> string, (s1,s2) -> s1+s2;
+cat("foo", -1);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:cat:NameProcessor)
+     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
+         +-(language::literal:"foo":ValueProcessor)
+         `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+             `-(language::integer:1:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("R argument conversion")
+    {
+      std::string_view data = R"(
+let cat : string*string -> string, (s1,s2) -> s1+s2;
+cat("foo", 2.5e-3);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:cat:NameProcessor)
+     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
+         +-(language::literal:"foo":ValueProcessor)
+         `-(language::real:2.5e-3:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+  }
+
   SECTION("errors")
   {
     SECTION("wrong argument number")
@@ -274,6 +393,7 @@ times_2_3(-2);
 let Id : Z -> Z, z -> z;
 Id(2,3);
 )";
+
       CHECK_AST_THROWS(data);
     }
 
@@ -283,7 +403,18 @@ Id(2,3);
 let sum : R*R -> R, (x,y) -> x+y;
 sum(2);
 )";
+
       CHECK_AST_THROWS(data);
     }
+
+    SECTION("invalid string conversion")
+    {
+      std::string_view data = R"(
+let bad_conv : string -> R, s -> s;
+bad_conv(2);
+)";
+
+      CHECK_AST_THROWS_WITH(data, std::string{"invalid string conversion"});
+    }
   }
 }