Add tests for FunctionTable/FunctionDescriptor

src/language/ASTNodeFunctionExpressionBuilder.cpp

@@ -80,7 +80,7 @@ ASTNodeFunctionExpressionBuilder::_buildArgumentProcessors(FunctionDescriptor& f
                                                            ASTNode& node,
                                                            FunctionProcessor& function_processor)
 {
-  ASTNode& definition_node     = function_descriptor.definitionNode();
+  const ASTNode& definition_node = function_descriptor.definitionNode();
   ASTNode& parameter_variables   = *definition_node.children[0];
 
   ASTNode& argument_nodes = *node.children[1];

src/language/FunctionTable.hpp

@@ -19,16 +19,16 @@ class FunctionDescriptor
 
  public:
   auto&
-  domainMappingNode()
+  domainMappingNode() const
   {
     Assert(m_domain_mapping_node, "undefined domain mapping node");
     return *m_domain_mapping_node;
   }
 
   auto&
-  definitionNode()
+  definitionNode() const
   {
-    Assert(m_domain_mapping_node, "undefined expression node");
+    Assert(m_definition_node, "undefined expression node");
     return *m_definition_node;
   }
 

tests/CMakeLists.txt

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

tests/test_FunctionTable.cpp

+#include <catch2/catch.hpp>
+
+#include <FunctionTable.hpp>
+
+TEST_CASE("FunctionTable", "[language]")
+{
+  rang::setControlMode(rang::control::Off);
+
+  SECTION("FunctionDescriptor")
+  {
+    std::unique_ptr domain_mapping_node = std::make_unique<ASTNode>();
+    domain_mapping_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+
+    std::unique_ptr definition_node = std::make_unique<ASTNode>();
+    definition_node->m_data_type    = ASTNodeDataType::double_t;
+    FunctionDescriptor f{std::move(domain_mapping_node), std::move(definition_node)};
+
+    REQUIRE(f.domainMappingNode().m_data_type == ASTNodeDataType::unsigned_int_t);
+    REQUIRE(f.definitionNode().m_data_type == ASTNodeDataType::double_t);
+
+    REQUIRE(domain_mapping_node == nullptr);
+    REQUIRE(definition_node == nullptr);
+  }
+
+#ifndef NDEBUG
+  SECTION("uninitialized FunctionDescriptor")
+  {
+    std::unique_ptr domain_mapping_node = std::make_unique<ASTNode>();
+    domain_mapping_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+
+    std::unique_ptr definition_node = std::make_unique<ASTNode>();
+    definition_node->m_data_type    = ASTNodeDataType::double_t;
+
+    SECTION("nothing initialized")
+    {
+      FunctionDescriptor f{nullptr, nullptr};
+      REQUIRE_THROWS_AS(f.domainMappingNode(), AssertError);
+      REQUIRE_THROWS_AS(f.definitionNode(), AssertError);
+    }
+
+    SECTION("domain mapping uninitialized")
+    {
+      FunctionDescriptor f{nullptr, std::move(definition_node)};
+      REQUIRE_THROWS_AS(f.domainMappingNode(), AssertError);
+      REQUIRE(f.definitionNode().m_data_type == ASTNodeDataType::double_t);
+      REQUIRE(definition_node == nullptr);
+    }
+
+    SECTION("definition node uninitialized")
+    {
+      FunctionDescriptor f{std::move(domain_mapping_node), nullptr};
+      REQUIRE_THROWS_AS(f.definitionNode(), AssertError);
+      REQUIRE(f.domainMappingNode().m_data_type == ASTNodeDataType::unsigned_int_t);
+      REQUIRE(domain_mapping_node == nullptr);
+    }
+  }
+#endif   // NDEBUG
+
+  FunctionTable table;
+
+  REQUIRE(table.size() == 0);
+
+  std::unique_ptr domain_mapping_node = std::make_unique<ASTNode>();
+  domain_mapping_node->m_data_type    = ASTNodeDataType::unsigned_int_t;
+
+  std::unique_ptr definition_node = std::make_unique<ASTNode>();
+  definition_node->m_data_type    = ASTNodeDataType::double_t;
+
+  size_t function_id = table.add(FunctionDescriptor{std::move(domain_mapping_node), std::move(definition_node)});
+
+  REQUIRE(domain_mapping_node == nullptr);
+  REQUIRE(definition_node == nullptr);
+
+  REQUIRE(function_id == 0);
+  REQUIRE(table.size() == 1);
+
+  const auto& const_table = table;
+  REQUIRE(const_table.size() == 1);
+
+  auto& f = table[function_id];
+  REQUIRE(f.domainMappingNode().m_data_type == ASTNodeDataType::unsigned_int_t);
+  REQUIRE(f.definitionNode().m_data_type == ASTNodeDataType::double_t);
+
+  const auto& const_f = const_table[function_id];
+  REQUIRE(const_f.domainMappingNode().m_data_type == ASTNodeDataType::unsigned_int_t);
+  REQUIRE(const_f.definitionNode().m_data_type == ASTNodeDataType::double_t);
+
+#ifndef NDEBUG
+  REQUIRE_THROWS_AS(table[table.size()], AssertError);
+  REQUIRE_THROWS_AS(const_table[const_table.size()], AssertError);
+#endif   // NDEBUG
+}