Add unit test for the internal namespace

.github/workflows/ci.yml

@@ -32,6 +32,9 @@ jobs:
       - name: Test production container
         run: |
           apptainer exec --writable-tmpfs hippo-release-${{ github.sha }}.sif bash -c "cd /opt/hippo && ./run_tests"
+      - name: Run unit tests in container
+        run: |
+          apptainer exec --writable-tmpfs hippo-release-${{ github.sha }}.sif bash -c "cd /opt/hippo/unit && make && ./run_tests"
       - name: Docs
         shell: bash
         run: |

include/util/hippoUtils.h

@@ -1,22 +1,54 @@
 #pragma once
 
+#include "MooseError.h"
 #include <InputParameters.h>
+#include <string>
 
 namespace Hippo
 {
+namespace
+{
+template <typename T>
+std::string
+getDemangleName()
+{
+  const char * mangled = typeid(T).name();
+  int status = 0;
+  std::unique_ptr<char> demangled(abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status));
+
+  return status == 0 ? demangled.get() : mangled;
+}
+}
+
 namespace internal
 {
 template <typename T>
 inline void
 copyParamFromParam(InputParameters & dst, const InputParameters & src, const std::string & name_in)
 {
-  if (src.isParamValid(name_in))
+  // Check the parameter is available in both src and dst
+  if (!src.have_parameter<T>(name_in))
+    mooseError("Parameter '",
+               name_in,
+               "' of type ",
+               getDemangleName<T>(),
+               " not available in src parameters.");
+
+  if (!dst.have_parameter<T>(name_in))
+    mooseError("Parameter '",
+               name_in,
+               "' of type ",
+               getDemangleName<T>(),
+               " not available in dst parameters.");
+
+  // Only set the parameter, if it has been set in src
+  if (src.isParamSetByUser(name_in))
     dst.set<T>(name_in) = src.get<T>(name_in);
 }
 
 template <typename StrType>
 inline std::string
-listFromVector(std::vector<StrType> vec, StrType sep = ", ")
+listFromVector(std::vector<StrType> vec, const char * sep = ", ")
 {
   if (vec.size() == 0)
     return std::string();

unit/src/InternalTests.C

@@ -0,0 +1,75 @@
+#include "gtest/gtest.h"
+#include <string>
+
+#include "InputParameters.h"
+#include "hippoUtils.h"
+
+#define EXPECT_THROW_MSG(statement, msg)                                                           \
+  try statement catch (const std::exception & e)                                                   \
+  {                                                                                                \
+    const std::string err_msg{std::string(e.what()) + " vs " + msg};                               \
+    EXPECT_TRUE(std::regex_search(e.what(), std::regex(msg))) << err_msg;                          \
+  }
+
+InputParameters
+setupParameters()
+{
+  libMesh::Parameters params;
+  params.insert<Real>("param1");
+  params.insert<Real>("param2");
+
+  return InputParameters(params);
+}
+
+TEST(HippoTestInternals, copyParamTest)
+{
+  InputParameters src(setupParameters());
+  InputParameters dst(setupParameters());
+
+  // Add parameters unique to each parameter set
+  src.addParam<Real>("param3", "");
+  dst.addParam<Real>("param4", "");
+
+  Hippo::internal::copyParamFromParam<Real>(dst, src, "param1");
+  Hippo::internal::copyParamFromParam<Real>(dst, src, "param2");
+
+  EXPECT_FALSE(dst.isParamSetByUser("param1")) << "param1 should not be set if src is not set";
+  EXPECT_FALSE(dst.isParamSetByUser("param2")) << "param2 should not be set if src is not set";
+
+  // Set source parameters
+  src.set<Real>("param1") = 4.2;
+  src.set<Real>("param2") = 2.1;
+
+  // Test copies
+  Hippo::internal::copyParamFromParam<Real>(dst, src, "param1");
+  EXPECT_DOUBLE_EQ(dst.get<Real>("param1"), 4.2) << "param1 doesn't match expect value";
+  Hippo::internal::copyParamFromParam<Real>(dst, src, "param2");
+  EXPECT_DOUBLE_EQ(dst.get<Real>("param2"), 2.1) << "param2 doesn't match expect value";
+
+  // Check missing parameters results in an excection
+  EXPECT_THROW_MSG(
+      { Hippo::internal::copyParamFromParam<Real>(dst, src, "param4"); },
+      "Parameter 'param4' of type double not available in src parameters.");
+  EXPECT_THROW_MSG(
+      { Hippo::internal::copyParamFromParam<Real>(dst, src, "param3"); },
+      "Parameter 'param3' of type double not available in dst parameters.");
+
+  // Check error through if the type is wrong
+  EXPECT_THROW_MSG(
+      { Hippo::internal::copyParamFromParam<std::string>(dst, src, "param1"); },
+      "Parameter 'param1' of type .* not available in src parameters.");
+}
+
+TEST(HippoTestInternals, ListFromVectorTest)
+{
+  std::vector<std::string> vec1{"item 1"};
+  std::vector<std::string> vec2{"item 1", "item 2"};
+
+  // Check lists of different sizes
+  EXPECT_EQ(Hippo::internal::listFromVector(std::vector<std::string>()), "");
+  EXPECT_EQ(Hippo::internal::listFromVector(vec1), "item 1");
+  EXPECT_EQ(Hippo::internal::listFromVector(vec2), "item 1, item 2");
+
+  // Check separator usage
+  EXPECT_EQ(Hippo::internal::listFromVector(vec2, " "), "item 1 item 2");
+}