From 92c34b1abca9930c1bc2dd66c4bb54c5546de788 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Wed, 24 Jul 2024 00:05:44 +0200
Subject: [PATCH] Refactor connectivity tests utilities

---
 .../checkpointing_Connectivity_utilities.hpp  | 192 ++++++++++++++++
 tests/test_checkpointing_Connectivity.cpp     | 205 ++----------------
 2 files changed, 208 insertions(+), 189 deletions(-)
 create mode 100644 tests/checkpointing_Connectivity_utilities.hpp

diff --git a/tests/checkpointing_Connectivity_utilities.hpp b/tests/checkpointing_Connectivity_utilities.hpp
new file mode 100644
index 000000000..a107ed78f
--- /dev/null
+++ b/tests/checkpointing_Connectivity_utilities.hpp
@@ -0,0 +1,192 @@
+#ifndef CHECKPOINTING_CONNECTIVITY_UTILITIES_HPP
+#define CHECKPOINTING_CONNECTIVITY_UTILITIES_HPP
+
+#include <mesh/Connectivity.hpp>
+#include <mesh/ConnectivityDescriptor.hpp>
+#include <utils/Messenger.hpp>
+#include <utils/PugsMacros.hpp>
+
+namespace test_only
+{
+
+PUGS_INLINE
+std::shared_ptr<const IConnectivity>
+duplicateConnectivity(const IConnectivity& i_connectivity)
+{
+  auto setRefItemLists = [](const auto& connectivity, ConnectivityDescriptor& descriptor) {
+    for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::cell>(); ++i) {
+      descriptor.addRefItemList(connectivity.template refItemList<ItemType::cell>(i));
+    }
+    for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::face>(); ++i) {
+      descriptor.addRefItemList(connectivity.template refItemList<ItemType::face>(i));
+    }
+    for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::edge>(); ++i) {
+      descriptor.addRefItemList(connectivity.template refItemList<ItemType::edge>(i));
+    }
+    for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::node>(); ++i) {
+      descriptor.addRefItemList(connectivity.template refItemList<ItemType::node>(i));
+    }
+  };
+
+  ConnectivityDescriptor descriptor;
+  switch (i_connectivity.dimension()) {
+  case 1: {
+    using ConnectivityType = Connectivity<1>;
+
+    const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
+    descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
+    descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
+
+    descriptor.setCellTypeVector(connectivity.cellType().arrayView());
+
+    descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
+    descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
+
+    descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
+
+    setRefItemLists(connectivity, descriptor);
+
+    return ConnectivityType::build(descriptor);
+  }
+  case 2: {
+    using ConnectivityType = Connectivity<2>;
+
+    const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
+    descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
+    descriptor.setFaceNumberVector(connectivity.faceNumber().arrayView());
+    descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
+
+    descriptor.setCellTypeVector(connectivity.cellType().arrayView());
+
+    descriptor.setCellFaceIsReversed(connectivity.cellFaceIsReversed().arrayView());
+
+    descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
+    descriptor.setFaceOwnerVector(connectivity.faceOwner().arrayView());
+    descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
+
+    descriptor.setCellToFaceMatrix(connectivity.getMatrix(ItemType::cell, ItemType::face));
+    descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
+    descriptor.setFaceToNodeMatrix(connectivity.getMatrix(ItemType::face, ItemType::node));
+
+    setRefItemLists(connectivity, descriptor);
+
+    return ConnectivityType::build(descriptor);
+  }
+  case 3: {
+    using ConnectivityType = Connectivity<3>;
+
+    const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
+    descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
+    descriptor.setFaceNumberVector(connectivity.faceNumber().arrayView());
+    descriptor.setEdgeNumberVector(connectivity.edgeNumber().arrayView());
+    descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
+
+    descriptor.setCellTypeVector(connectivity.cellType().arrayView());
+
+    descriptor.setCellFaceIsReversed(connectivity.cellFaceIsReversed().arrayView());
+    descriptor.setFaceEdgeIsReversed(connectivity.faceEdgeIsReversed().arrayView());
+
+    descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
+    descriptor.setFaceOwnerVector(connectivity.faceOwner().arrayView());
+    descriptor.setEdgeOwnerVector(connectivity.edgeOwner().arrayView());
+    descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
+
+    descriptor.setCellToFaceMatrix(connectivity.getMatrix(ItemType::cell, ItemType::face));
+    descriptor.setCellToEdgeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::edge));
+    descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
+    descriptor.setFaceToEdgeMatrix(connectivity.getMatrix(ItemType::face, ItemType::edge));
+    descriptor.setFaceToNodeMatrix(connectivity.getMatrix(ItemType::face, ItemType::node));
+    descriptor.setEdgeToNodeMatrix(connectivity.getMatrix(ItemType::edge, ItemType::node));
+
+    setRefItemLists(connectivity, descriptor);
+
+    return ConnectivityType::build(descriptor);
+  }
+  default: {
+    throw UnexpectedError("invalid connectivity");
+  }
+  }
+}
+
+template <size_t Dimension>
+PUGS_INLINE bool
+isSameConnectivity(const Connectivity<Dimension>& connectivity, const Connectivity<Dimension>& read_connectivity)
+{
+  using ConnectivityType = std::decay_t<decltype(connectivity)>;
+
+  auto same_value = [](const auto& a, const auto& b) -> bool {
+    bool same = true;
+    for (size_t i = 0; i < a.size(); ++i) {
+      same &= (a[i] == b[i]);
+    }
+    return parallel::allReduceAnd(same);
+  };
+
+  auto same_ref_item_list = [&same_value](const auto& a, const auto& b) -> bool {
+    REQUIRE(a.type() == b.type());
+    REQUIRE(a.refId() == b.refId());
+
+    return same_value(a.list(), b.list());
+  };
+
+  bool same = true;
+  same &= same_value(connectivity.cellNumber().arrayView(), read_connectivity.cellNumber().arrayView());
+  same &= same_value(connectivity.nodeNumber().arrayView(), read_connectivity.nodeNumber().arrayView());
+
+  same &= same_value(connectivity.cellType().arrayView(), read_connectivity.cellType().arrayView());
+
+  same &= same_value(connectivity.cellOwner().arrayView(), read_connectivity.cellOwner().arrayView());
+  same &= same_value(connectivity.nodeOwner().arrayView(), read_connectivity.nodeOwner().arrayView());
+
+  same &= same_value(connectivity.cellToNodeMatrix().values(), read_connectivity.cellToNodeMatrix().values());
+
+  if constexpr (ConnectivityType::Dimension >= 2) {
+    same &= same_value(connectivity.faceNumber().arrayView(), read_connectivity.faceNumber().arrayView());
+    same &= same_value(connectivity.faceOwner().arrayView(), read_connectivity.faceOwner().arrayView());
+    same &=
+      same_value(connectivity.cellFaceIsReversed().arrayView(), read_connectivity.cellFaceIsReversed().arrayView());
+    same &= same_value(connectivity.cellToFaceMatrix().values(), read_connectivity.cellToFaceMatrix().values());
+    same &= same_value(connectivity.faceToNodeMatrix().values(), read_connectivity.faceToNodeMatrix().values());
+  }
+
+  if constexpr (ConnectivityType::Dimension == 3) {
+    same &= same_value(connectivity.edgeNumber().arrayView(), read_connectivity.edgeNumber().arrayView());
+    same &= same_value(connectivity.edgeOwner().arrayView(), read_connectivity.edgeOwner().arrayView());
+    same &=
+      same_value(connectivity.faceEdgeIsReversed().arrayView(), read_connectivity.faceEdgeIsReversed().arrayView());
+    same &= same_value(connectivity.cellToEdgeMatrix().values(), read_connectivity.cellToEdgeMatrix().values());
+    same &= same_value(connectivity.faceToEdgeMatrix().values(), read_connectivity.faceToEdgeMatrix().values());
+    same &= same_value(connectivity.edgeToNodeMatrix().values(), read_connectivity.edgeToNodeMatrix().values());
+  }
+
+  REQUIRE(connectivity.template numberOfRefItemList<ItemType::cell>() ==
+          read_connectivity.template numberOfRefItemList<ItemType::cell>());
+  for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::cell>(); ++i) {
+    same &= same_ref_item_list(connectivity.template refItemList<ItemType::cell>(i),
+                               read_connectivity.template refItemList<ItemType::cell>(i));
+  }
+  REQUIRE(connectivity.template numberOfRefItemList<ItemType::face>() ==
+          read_connectivity.template numberOfRefItemList<ItemType::face>());
+  for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::face>(); ++i) {
+    same &= same_ref_item_list(connectivity.template refItemList<ItemType::face>(i),
+                               read_connectivity.template refItemList<ItemType::face>(i));
+  }
+  REQUIRE(connectivity.template numberOfRefItemList<ItemType::edge>() ==
+          read_connectivity.template numberOfRefItemList<ItemType::edge>());
+  for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::edge>(); ++i) {
+    same &= same_ref_item_list(connectivity.template refItemList<ItemType::edge>(i),
+                               read_connectivity.template refItemList<ItemType::edge>(i));
+  }
+  REQUIRE(connectivity.template numberOfRefItemList<ItemType::node>() ==
+          read_connectivity.template numberOfRefItemList<ItemType::node>());
+  for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::node>(); ++i) {
+    same &= same_ref_item_list(connectivity.template refItemList<ItemType::node>(i),
+                               read_connectivity.template refItemList<ItemType::node>(i));
+  }
+
+  return same;
+}
+
+}   // namespace test_only
+
+#endif   // CHECKPOINTING_CONNECTIVITY_UTILITIES_HPP
diff --git a/tests/test_checkpointing_Connectivity.cpp b/tests/test_checkpointing_Connectivity.cpp
index c65e4a93d..6334973bf 100644
--- a/tests/test_checkpointing_Connectivity.cpp
+++ b/tests/test_checkpointing_Connectivity.cpp
@@ -5,8 +5,6 @@
 
 #include <language/utils/DataHandler.hpp>
 #include <language/utils/EmbeddedData.hpp>
-#include <mesh/ConnectivityDescriptor.hpp>
-#include <mesh/ConnectivityMatrix.hpp>
 #include <mesh/Mesh.hpp>
 #include <mesh/MeshVariant.hpp>
 #include <utils/GlobalVariableManager.hpp>
@@ -14,6 +12,7 @@
 #include <utils/checkpointing/WriteConnectivity.hpp>
 
 #include <MeshDataBaseForTests.hpp>
+#include <checkpointing_Connectivity_utilities.hpp>
 
 #include <filesystem>
 
@@ -50,109 +49,13 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
       HighFive::Group checkpoint_group_1 = file.createGroup("checkpoint_1");
       HighFive::Group useless_group;
 
-      auto duplicate_connectivity = [](const IConnectivity& i_connectivity) -> std::shared_ptr<const IConnectivity> {
-        auto setRefItemLists = [](const auto& connectivity, ConnectivityDescriptor& descriptor) {
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::cell>(); ++i) {
-            descriptor.addRefItemList(connectivity.template refItemList<ItemType::cell>(i));
-          }
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::face>(); ++i) {
-            descriptor.addRefItemList(connectivity.template refItemList<ItemType::face>(i));
-          }
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::edge>(); ++i) {
-            descriptor.addRefItemList(connectivity.template refItemList<ItemType::edge>(i));
-          }
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::node>(); ++i) {
-            descriptor.addRefItemList(connectivity.template refItemList<ItemType::node>(i));
-          }
-        };
-
-        ConnectivityDescriptor descriptor;
-        switch (i_connectivity.dimension()) {
-        case 1: {
-          using ConnectivityType = Connectivity<1>;
-
-          const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
-          descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
-          descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
-
-          descriptor.setCellTypeVector(connectivity.cellType().arrayView());
-
-          descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
-          descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
-
-          descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
-
-          setRefItemLists(connectivity, descriptor);
-
-          return ConnectivityType::build(descriptor);
-        }
-        case 2: {
-          using ConnectivityType = Connectivity<2>;
-
-          const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
-          descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
-          descriptor.setFaceNumberVector(connectivity.faceNumber().arrayView());
-          descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
-
-          descriptor.setCellTypeVector(connectivity.cellType().arrayView());
-
-          descriptor.setCellFaceIsReversed(connectivity.cellFaceIsReversed().arrayView());
-
-          descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
-          descriptor.setFaceOwnerVector(connectivity.faceOwner().arrayView());
-          descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
-
-          descriptor.setCellToFaceMatrix(connectivity.getMatrix(ItemType::cell, ItemType::face));
-          descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
-          descriptor.setFaceToNodeMatrix(connectivity.getMatrix(ItemType::face, ItemType::node));
-
-          setRefItemLists(connectivity, descriptor);
-
-          return ConnectivityType::build(descriptor);
-        }
-        case 3: {
-          using ConnectivityType = Connectivity<3>;
-
-          const ConnectivityType& connectivity = dynamic_cast<const ConnectivityType&>(i_connectivity);
-          descriptor.setCellNumberVector(connectivity.cellNumber().arrayView());
-          descriptor.setFaceNumberVector(connectivity.faceNumber().arrayView());
-          descriptor.setEdgeNumberVector(connectivity.edgeNumber().arrayView());
-          descriptor.setNodeNumberVector(connectivity.nodeNumber().arrayView());
-
-          descriptor.setCellTypeVector(connectivity.cellType().arrayView());
-
-          descriptor.setCellFaceIsReversed(connectivity.cellFaceIsReversed().arrayView());
-          descriptor.setFaceEdgeIsReversed(connectivity.faceEdgeIsReversed().arrayView());
-
-          descriptor.setCellOwnerVector(connectivity.cellOwner().arrayView());
-          descriptor.setFaceOwnerVector(connectivity.faceOwner().arrayView());
-          descriptor.setEdgeOwnerVector(connectivity.edgeOwner().arrayView());
-          descriptor.setNodeOwnerVector(connectivity.nodeOwner().arrayView());
-
-          descriptor.setCellToFaceMatrix(connectivity.getMatrix(ItemType::cell, ItemType::face));
-          descriptor.setCellToEdgeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::edge));
-          descriptor.setCellToNodeMatrix(connectivity.getMatrix(ItemType::cell, ItemType::node));
-          descriptor.setFaceToEdgeMatrix(connectivity.getMatrix(ItemType::face, ItemType::edge));
-          descriptor.setFaceToNodeMatrix(connectivity.getMatrix(ItemType::face, ItemType::node));
-          descriptor.setEdgeToNodeMatrix(connectivity.getMatrix(ItemType::edge, ItemType::node));
-
-          setRefItemLists(connectivity, descriptor);
-
-          return ConnectivityType::build(descriptor);
-        }
-        default: {
-          throw UnexpectedError("invalid connectivity");
-        }
-        }
-      };
-
       {   // Write
         auto mesh_1d = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
         // creates artificially holes in numbering
-        duplicate_connectivity(mesh_1d->connectivity());
+        test_only::duplicateConnectivity(mesh_1d->connectivity());
 
-        auto new_connectivity_1d = duplicate_connectivity(mesh_1d->connectivity());
+        auto new_connectivity_1d = test_only::duplicateConnectivity(mesh_1d->connectivity());
         checkpointing::writeConnectivity(*new_connectivity_1d, file, checkpoint_group_0);
         checkpointing::writeConnectivity(*new_connectivity_1d, file, checkpoint_group_1);
         connectivity_id_map[mesh_1d->id()] = new_connectivity_1d->id();
@@ -160,10 +63,10 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
         auto mesh_2d = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
         // creates artificially holes in numbering
-        duplicate_connectivity(mesh_2d->connectivity());
-        duplicate_connectivity(mesh_2d->connectivity());
+        test_only::duplicateConnectivity(mesh_2d->connectivity());
+        test_only::duplicateConnectivity(mesh_2d->connectivity());
 
-        auto new_connectivity_2d = duplicate_connectivity(mesh_2d->connectivity());
+        auto new_connectivity_2d = test_only::duplicateConnectivity(mesh_2d->connectivity());
 
         checkpointing::writeConnectivity(*new_connectivity_2d, file, checkpoint_group_0);
         checkpointing::writeConnectivity(*new_connectivity_2d, file, checkpoint_group_1);
@@ -177,21 +80,21 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
         auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
         // creates artificially holes in numbering
-        duplicate_connectivity(mesh_3d->connectivity());
+        test_only::duplicateConnectivity(mesh_3d->connectivity());
 
-        auto new_connectivity_3d = duplicate_connectivity(mesh_3d->connectivity());
+        auto new_connectivity_3d = test_only::duplicateConnectivity(mesh_3d->connectivity());
         checkpointing::writeConnectivity(*new_connectivity_3d, file, checkpoint_group_1);
         connectivity_id_map[mesh_3d->id()] = new_connectivity_3d->id();
 
+        // creates artificially holes in numbering
+        test_only::duplicateConnectivity(mesh_3d->connectivity());
+        test_only::duplicateConnectivity(mesh_3d->connectivity());
+        test_only::duplicateConnectivity(mesh_3d->connectivity());
+
         HighFive::Group global_variables_group_1 = checkpoint_group_1.createGroup("singleton/global_variables");
         global_variables_group_1.createAttribute("connectivity_id",
                                                  GlobalVariableManager::instance().getConnectivityId());
         global_variables_group_1.createAttribute("mesh_id", GlobalVariableManager::instance().getMeshId());
-
-        // creates artificially holes in numbering
-        duplicate_connectivity(mesh_3d->connectivity());
-        duplicate_connectivity(mesh_3d->connectivity());
-        duplicate_connectivity(mesh_3d->connectivity());
       }
 
       // reset to reuse after resuming
@@ -204,82 +107,6 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
 
       GlobalVariableManager::instance().setConnectivityId(initial_connectivity_id);
       {   // Read
-        auto is_same = [](const auto& connectivity, const auto& read_connectivity) -> bool {
-          static_assert(std::is_same_v<decltype(connectivity), decltype(read_connectivity)>);
-          using ConnectivityType = std::decay_t<decltype(connectivity)>;
-
-          auto same_value = [](const auto& a, const auto& b) -> bool {
-            bool same = true;
-            for (size_t i = 0; i < a.size(); ++i) {
-              same &= (a[i] == b[i]);
-            }
-            return parallel::allReduceAnd(same);
-          };
-
-          auto same_ref_item_list = [&same_value](const auto& a, const auto& b) -> bool {
-            REQUIRE(a.type() == b.type());
-            REQUIRE(a.refId() == b.refId());
-
-            return same_value(a.list(), b.list());
-          };
-
-          bool same = true;
-          same &= same_value(connectivity.cellNumber().arrayView(), read_connectivity.cellNumber().arrayView());
-          same &= same_value(connectivity.nodeNumber().arrayView(), read_connectivity.nodeNumber().arrayView());
-
-          same &= same_value(connectivity.cellType().arrayView(), read_connectivity.cellType().arrayView());
-
-          same &= same_value(connectivity.cellOwner().arrayView(), read_connectivity.cellOwner().arrayView());
-          same &= same_value(connectivity.nodeOwner().arrayView(), read_connectivity.nodeOwner().arrayView());
-
-          same &= same_value(connectivity.cellToNodeMatrix().values(), read_connectivity.cellToNodeMatrix().values());
-
-          if constexpr (ConnectivityType::Dimension >= 2) {
-            same &= same_value(connectivity.faceNumber().arrayView(), read_connectivity.faceNumber().arrayView());
-            same &= same_value(connectivity.faceOwner().arrayView(), read_connectivity.faceOwner().arrayView());
-            same &= same_value(connectivity.cellFaceIsReversed().arrayView(),
-                               read_connectivity.cellFaceIsReversed().arrayView());
-            same &= same_value(connectivity.cellToFaceMatrix().values(), read_connectivity.cellToFaceMatrix().values());
-            same &= same_value(connectivity.faceToNodeMatrix().values(), read_connectivity.faceToNodeMatrix().values());
-          }
-
-          if constexpr (ConnectivityType::Dimension == 3) {
-            same &= same_value(connectivity.edgeNumber().arrayView(), read_connectivity.edgeNumber().arrayView());
-            same &= same_value(connectivity.edgeOwner().arrayView(), read_connectivity.edgeOwner().arrayView());
-            same &= same_value(connectivity.faceEdgeIsReversed().arrayView(),
-                               read_connectivity.faceEdgeIsReversed().arrayView());
-            same &= same_value(connectivity.cellToEdgeMatrix().values(), read_connectivity.cellToEdgeMatrix().values());
-            same &= same_value(connectivity.faceToEdgeMatrix().values(), read_connectivity.faceToEdgeMatrix().values());
-            same &= same_value(connectivity.edgeToNodeMatrix().values(), read_connectivity.edgeToNodeMatrix().values());
-          }
-
-          REQUIRE(connectivity.template numberOfRefItemList<ItemType::cell>() ==
-                  read_connectivity.template numberOfRefItemList<ItemType::cell>());
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::cell>(); ++i) {
-            same &= same_ref_item_list(connectivity.template refItemList<ItemType::cell>(i),
-                                       read_connectivity.template refItemList<ItemType::cell>(i));
-          }
-          REQUIRE(connectivity.template numberOfRefItemList<ItemType::face>() ==
-                  read_connectivity.template numberOfRefItemList<ItemType::face>());
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::face>(); ++i) {
-            same &= same_ref_item_list(connectivity.template refItemList<ItemType::face>(i),
-                                       read_connectivity.template refItemList<ItemType::face>(i));
-          }
-          REQUIRE(connectivity.template numberOfRefItemList<ItemType::edge>() ==
-                  read_connectivity.template numberOfRefItemList<ItemType::edge>());
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::edge>(); ++i) {
-            same &= same_ref_item_list(connectivity.template refItemList<ItemType::edge>(i),
-                                       read_connectivity.template refItemList<ItemType::edge>(i));
-          }
-          REQUIRE(connectivity.template numberOfRefItemList<ItemType::node>() ==
-                  read_connectivity.template numberOfRefItemList<ItemType::node>());
-          for (size_t i = 0; i < connectivity.template numberOfRefItemList<ItemType::node>(); ++i) {
-            same &= same_ref_item_list(connectivity.template refItemList<ItemType::node>(i),
-                                       read_connectivity.template refItemList<ItemType::node>(i));
-          }
-
-          return same;
-        };
 
         auto mesh_1d = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
@@ -290,7 +117,7 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
 
         const Connectivity<1>& read_connectivity_1d = dynamic_cast<const Connectivity<1>&>(*p_new_connectivity_1d);
 
-        REQUIRE(is_same(connectivity_1d, read_connectivity_1d));
+        REQUIRE(test_only::isSameConnectivity(connectivity_1d, read_connectivity_1d));
 
         auto mesh_2d = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
@@ -301,7 +128,7 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
 
         const Connectivity<2>& read_connectivity_2d = dynamic_cast<const Connectivity<2>&>(*p_new_connectivity_2d);
 
-        REQUIRE(is_same(connectivity_2d, read_connectivity_2d));
+        REQUIRE(test_only::isSameConnectivity(connectivity_2d, read_connectivity_2d));
 
         auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
@@ -312,7 +139,7 @@ TEST_CASE("checkpointing_Connectivity", "[utils/checkpointing]")
 
         const Connectivity<3>& read_connectivity_3d = dynamic_cast<const Connectivity<3>&>(*p_new_connectivity_3d);
 
-        REQUIRE(is_same(connectivity_3d, read_connectivity_3d));
+        REQUIRE(test_only::isSameConnectivity(connectivity_3d, read_connectivity_3d));
       }
       checkpointing::ResumingData::destroy();
     }
-- 
GitLab