Add tests for ASTNodeNaturalConversionChecker

src/language/ASTNodeNaturalConversionChecker.cpp

@@ -46,8 +46,7 @@ ASTNodeNaturalConversionChecker::_checkIsNaturalExpressionConversion(const ASTNo
           break;
         }
       }
-      this->_checkIsNaturalTypeConversion(node, data_type, target_data_type);
-      break;
+      [[fallthrough]];
     }
     default: {
       this->_checkIsNaturalTypeConversion(node, data_type, target_data_type);

tests/CMakeLists.txt

@@ -27,6 +27,7 @@ add_executable (unit_tests
   test_ASTNodeJumpPlacementChecker.cpp
   test_ASTNodeListAffectationExpressionBuilder.cpp
   test_ASTNodeListProcessor.cpp
+  test_ASTNodeNaturalConversionChecker.cpp
   test_ASTNodeTypeCleaner.cpp
   test_ASTNodeUnaryOperatorExpressionBuilder.cpp
   test_ASTPrinter.cpp

tests/test_ASTNodeNaturalConversionChecker.cpp

+#include <catch2/catch.hpp>
+
+#include <ASTNodeNaturalConversionChecker.hpp>
+
+#include <ASTNode.hpp>
+#include <PEGGrammar.hpp>
+
+TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
+{
+  SECTION("Valid conversions")
+  {
+    std::unique_ptr data_node = std::make_unique<ASTNode>();
+
+    SECTION("-> string")
+    {
+      SECTION("string -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+
+      SECTION("R^d -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::vector_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+
+      SECTION("R -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+
+      SECTION("Z -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+
+      SECTION("N -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+
+      SECTION("B -> string")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::string_t});
+      }
+    }
+
+    SECTION("-> R^d")
+    {
+      SECTION("R^1 -> R^1")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 1}});
+      }
+
+      SECTION("list -> R^1")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+        }
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 1}});
+      }
+
+      SECTION("'0' -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::int_t, 1};
+        data_node->set_type<language::integer>();
+        data_node->source  = "0";
+        auto& source       = data_node->source;
+        data_node->m_begin = TAO_PEGTL_NAMESPACE::internal::iterator{&source[0]};
+        data_node->m_end   = TAO_PEGTL_NAMESPACE::internal::iterator{&source[source.size()]};
+
+        SECTION("d = 1")
+        {
+          REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 1}});
+        }
+        SECTION("d = 2")
+        {
+          REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 2}});
+        }
+        SECTION("d = 3")
+        {
+          REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 3}});
+        }
+      }
+
+      SECTION("R^2 -> R^2")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 2}});
+      }
+
+      SECTION("list -> R^2")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+
+          std::unique_ptr list1_node = std::make_unique<ASTNode>();
+          list1_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+          data_node->emplace_back(std::move(list1_node));
+        }
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 2}});
+      }
+
+      SECTION("R^3 -> R^3")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 3}});
+      }
+
+      SECTION("list -> R^3")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+
+          std::unique_ptr list1_node = std::make_unique<ASTNode>();
+          list1_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+          data_node->emplace_back(std::move(list1_node));
+
+          std::unique_ptr list2_node = std::make_unique<ASTNode>();
+          list2_node->m_data_type    = ASTNodeDataType::int_t;
+          data_node->emplace_back(std::move(list2_node));
+        }
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType{ASTNodeDataType::vector_t, 3}});
+      }
+    }
+
+    SECTION("-> R")
+    {
+      SECTION("R -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t});
+      }
+
+      SECTION("Z -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t});
+      }
+
+      SECTION("N -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t});
+      }
+
+      SECTION("B -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t});
+      }
+    }
+
+    SECTION("-> Z")
+    {
+      SECTION("Z -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t});
+      }
+
+      SECTION("N -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t});
+      }
+
+      SECTION("B -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t});
+      }
+    }
+
+    SECTION("-> N")
+    {
+      SECTION("Z -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t});
+      }
+
+      SECTION("N -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t});
+      }
+
+      SECTION("B -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t});
+      }
+    }
+
+    SECTION("-> B")
+    {
+      SECTION("B -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+        REQUIRE_NOTHROW(ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t});
+      }
+    }
+  }
+
+  SECTION("Invalid conversions")
+  {
+    std::unique_ptr data_node = std::make_unique<ASTNode>();
+
+    SECTION("-> R^d")
+    {
+      SECTION("R^2 -> R^1")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("R^3 -> R^1")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("R^1 -> R^2")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("R^3 -> R^2")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("R^1 -> R^3")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("R^2 -> R^3")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                             ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                            "incompatible dimensions in affectation");
+      }
+
+      SECTION("list1 -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "incompatible dimensions in affectation");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "incompatible dimensions in affectation");
+        }
+      }
+
+      SECTION("list2 -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+
+          std::unique_ptr list1_node = std::make_unique<ASTNode>();
+          list1_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+          data_node->emplace_back(std::move(list1_node));
+        }
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "incompatible dimensions in affectation");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "incompatible dimensions in affectation");
+        }
+      }
+
+      SECTION("list3 -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::list_t;
+        {
+          std::unique_ptr list0_node = std::make_unique<ASTNode>();
+          list0_node->m_data_type    = ASTNodeDataType::double_t;
+          data_node->emplace_back(std::move(list0_node));
+
+          std::unique_ptr list1_node = std::make_unique<ASTNode>();
+          list1_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+          data_node->emplace_back(std::move(list1_node));
+
+          std::unique_ptr list2_node = std::make_unique<ASTNode>();
+          list2_node->m_data_type    = ASTNodeDataType::int_t;
+          data_node->emplace_back(std::move(list2_node));
+        }
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "incompatible dimensions in affectation");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "incompatible dimensions in affectation");
+        }
+      }
+
+      SECTION("R -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "invalid implicit conversion: R -> R^1");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "invalid implicit conversion: R -> R^2");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "invalid implicit conversion: R -> R^3");
+        }
+      }
+
+      SECTION("Z -> R^d (non-zero)")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        data_node->set_type<language::integer>();
+        data_node->source  = "1";
+        auto& source       = data_node->source;
+        data_node->m_begin = TAO_PEGTL_NAMESPACE::internal::iterator{&source[0]};
+        data_node->m_end   = TAO_PEGTL_NAMESPACE::internal::iterator{&source[source.size()]};
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "invalid implicit conversion: Z -> R^1");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "invalid implicit conversion: Z -> R^2");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "invalid implicit conversion: Z -> R^3");
+        }
+      }
+
+      SECTION("N -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "invalid implicit conversion: N -> R^1");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "invalid implicit conversion: N -> R^2");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "invalid implicit conversion: N -> R^3");
+        }
+      }
+
+      SECTION("B -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::bool_t;
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "invalid implicit conversion: B -> R^1");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "invalid implicit conversion: B -> R^2");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "invalid implicit conversion: B -> R^3");
+        }
+      }
+
+      SECTION("string -> R^d")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+
+        SECTION("d=1")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 1}}),
+                              "invalid implicit conversion: string -> R^1");
+        }
+
+        SECTION("d=2")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 2}}),
+                              "invalid implicit conversion: string -> R^2");
+        }
+
+        SECTION("d=3")
+        {
+          REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+                                                               ASTNodeDataType{ASTNodeDataType::vector_t, 3}}),
+                              "invalid implicit conversion: string -> R^3");
+        }
+      }
+    }
+
+    SECTION("-> R")
+    {
+      SECTION("string -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t}),
+                            "invalid implicit conversion: string -> R");
+      }
+
+      SECTION("R^1 -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t}),
+                            "invalid implicit conversion: R^1 -> R");
+      }
+
+      SECTION("R^2 -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t}),
+                            "invalid implicit conversion: R^2 -> R");
+      }
+
+      SECTION("R^3 -> R")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::double_t}),
+                            "invalid implicit conversion: R^3 -> R");
+      }
+    }
+
+    SECTION("-> Z")
+    {
+      SECTION("string -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t}),
+                            "invalid implicit conversion: string -> Z");
+      }
+
+      SECTION("R^1 -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t}),
+                            "invalid implicit conversion: R^1 -> Z");
+      }
+
+      SECTION("R^2 -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t}),
+                            "invalid implicit conversion: R^2 -> Z");
+      }
+
+      SECTION("R^3 -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t}),
+                            "invalid implicit conversion: R^3 -> Z");
+      }
+
+      SECTION("R -> Z")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::int_t}),
+                            "invalid implicit conversion: R -> Z");
+      }
+    }
+
+    SECTION("-> N")
+    {
+      SECTION("string -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t}),
+                            "invalid implicit conversion: string -> N");
+      }
+
+      SECTION("R^1 -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t}),
+                            "invalid implicit conversion: R^1 -> N");
+      }
+
+      SECTION("R^2 -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t}),
+                            "invalid implicit conversion: R^2 -> N");
+      }
+
+      SECTION("R^3 -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t}),
+                            "invalid implicit conversion: R^3 -> N");
+      }
+
+      SECTION("R -> N")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::unsigned_int_t}),
+                            "invalid implicit conversion: R -> N");
+      }
+    }
+
+    SECTION("-> B")
+    {
+      SECTION("string -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType::string_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: string -> B");
+      }
+
+      SECTION("R^1 -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 1};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: R^1 -> B");
+      }
+
+      SECTION("R^2 -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 2};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: R^2 -> B");
+      }
+
+      SECTION("R^3 -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType{ASTNodeDataType::vector_t, 3};
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: R^3 -> B");
+      }
+
+      SECTION("R -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType::double_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: R -> B");
+      }
+
+      SECTION("Z -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType::int_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: Z -> B");
+      }
+      SECTION("N -> B")
+      {
+        data_node->m_data_type = ASTNodeDataType::unsigned_int_t;
+        REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::bool_t}),
+                            "invalid implicit conversion: N -> B");
+      }
+    }
+  }
+}