diff --git a/tests/test_DualMeshManager.cpp b/tests/test_DualMeshManager.cpp
index e5c8dbcf83d5296390be98725e3fbca887464f5f..1d05b996ae569ea30e995e5b1c8422b1edb9aeef 100644
--- a/tests/test_DualMeshManager.cpp
+++ b/tests/test_DualMeshManager.cpp
@@ -11,89 +11,149 @@
 
 TEST_CASE("DualMeshManager", "[mesh]")
 {
-  using ConnectivityType = Connectivity<2>;
-  using MeshType         = Mesh<ConnectivityType>;
+  SECTION("same 1D dual connectivities ")
+  {
+    using ConnectivityType = Connectivity<1>;
+    using MeshType         = Mesh<ConnectivityType>;
 
-  std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh();
+    std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().unordered1DMesh();
 
-  SECTION("diamond dual mesh access")
-  {
     std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+    std::shared_ptr p_median_dual_mesh  = DualMeshManager::instance().getMedianDualMesh(*mesh);
+    std::shared_ptr p_dual1d_mesh       = DualMeshManager::instance().getDual1DMesh(*mesh);
+
+    // In 1d all these dual meshes are the same
+    REQUIRE(p_dual1d_mesh.get() == p_diamond_dual_mesh.get());
+    REQUIRE(p_dual1d_mesh.get() == p_median_dual_mesh.get());
+  }
+
+  SECTION("2D")
+  {
+    using ConnectivityType = Connectivity<2>;
+    using MeshType         = Mesh<ConnectivityType>;
 
-    const auto ref_counter = p_diamond_dual_mesh.use_count();
+    std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh();
 
+    SECTION("diamond dual mesh access")
     {
-      std::shared_ptr p_diamond_dual_mesh2 = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+      std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh);
 
-      REQUIRE(p_diamond_dual_mesh == p_diamond_dual_mesh2);
-      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter + 1);
-    }
+      const auto ref_counter = p_diamond_dual_mesh.use_count();
 
-    REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter);
+      {
+        std::shared_ptr p_diamond_dual_mesh2 = DualMeshManager::instance().getDiamondDualMesh(*mesh);
 
-    DualMeshManager::instance().deleteMesh(mesh.get());
-    REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
+        REQUIRE(p_diamond_dual_mesh == p_diamond_dual_mesh2);
+        REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter + 1);
+      }
 
-    // Can delete mesh from the list again. This means that no
-    // dual mesh associated with it is managed.
-    REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
-    REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter);
 
-    // A new dual mesh is built
-    std::shared_ptr p_diamond_dual_mesh_rebuilt = DualMeshManager::instance().getDiamondDualMesh(*mesh);
-    REQUIRE(p_diamond_dual_mesh != p_diamond_dual_mesh_rebuilt);
-    REQUIRE(p_diamond_dual_mesh.get() != p_diamond_dual_mesh_rebuilt.get());
+      DualMeshManager::instance().deleteMesh(mesh.get());
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
 
-    // Exactly two references to the dual mesh. One here and
-    // one in the manager.
-    REQUIRE(p_diamond_dual_mesh_rebuilt.use_count() == 2);
-  }
+      // Can delete mesh from the list again. This means that no
+      // dual mesh associated with it is managed.
+      REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
 
-  SECTION("median dual mesh access")
-  {
-    std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(*mesh);
+      // A new dual mesh is built
+      std::shared_ptr p_diamond_dual_mesh_rebuilt = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+      REQUIRE(p_diamond_dual_mesh != p_diamond_dual_mesh_rebuilt);
+      REQUIRE(p_diamond_dual_mesh.get() != p_diamond_dual_mesh_rebuilt.get());
 
-    const auto ref_counter = p_median_dual_mesh.use_count();
+      // Exactly two references to the dual mesh. One here and
+      // one in the manager.
+      REQUIRE(p_diamond_dual_mesh_rebuilt.use_count() == 2);
+    }
 
+    SECTION("median dual mesh access")
     {
-      std::shared_ptr p_median_dual_mesh2 = DualMeshManager::instance().getMedianDualMesh(*mesh);
+      std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(*mesh);
 
-      REQUIRE(p_median_dual_mesh == p_median_dual_mesh2);
-      REQUIRE(p_median_dual_mesh.use_count() == ref_counter + 1);
-    }
+      const auto ref_counter = p_median_dual_mesh.use_count();
+
+      {
+        std::shared_ptr p_median_dual_mesh2 = DualMeshManager::instance().getMedianDualMesh(*mesh);
+
+        REQUIRE(p_median_dual_mesh == p_median_dual_mesh2);
+        REQUIRE(p_median_dual_mesh.use_count() == ref_counter + 1);
+      }
+
+      REQUIRE(p_median_dual_mesh.use_count() == ref_counter);
+
+      DualMeshManager::instance().deleteMesh(mesh.get());
+      REQUIRE(p_median_dual_mesh.use_count() == ref_counter - 1);
 
-    REQUIRE(p_median_dual_mesh.use_count() == ref_counter);
+      // Can delete mesh from the list again. This means that no
+      // dual mesh associated with it is managed.
+      REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
+      REQUIRE(p_median_dual_mesh.use_count() == ref_counter - 1);
 
-    DualMeshManager::instance().deleteMesh(mesh.get());
-    REQUIRE(p_median_dual_mesh.use_count() == ref_counter - 1);
+      // A new dual mesh is built
+      std::shared_ptr p_median_dual_mesh_rebuilt = DualMeshManager::instance().getMedianDualMesh(*mesh);
+      REQUIRE(p_median_dual_mesh != p_median_dual_mesh_rebuilt);
+      REQUIRE(p_median_dual_mesh.get() != p_median_dual_mesh_rebuilt.get());
 
-    // Can delete mesh from the list again. This means that no
-    // dual mesh associated with it is managed.
-    REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
-    REQUIRE(p_median_dual_mesh.use_count() == ref_counter - 1);
+      // Exactly two references to the dual mesh. One here and
+      // one in the manager.
+      REQUIRE(p_median_dual_mesh_rebuilt.use_count() == 2);
+    }
+
+    SECTION("check multiple dual mesh using/freeing")
+    {
+      std::shared_ptr p_median_dual_mesh  = DualMeshManager::instance().getMedianDualMesh(*mesh);
+      std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+
+      const auto median_ref_counter  = p_median_dual_mesh.use_count();
+      const auto diamond_ref_counter = p_diamond_dual_mesh.use_count();
 
-    // A new dual mesh is built
-    std::shared_ptr p_median_dual_mesh_rebuilt = DualMeshManager::instance().getMedianDualMesh(*mesh);
-    REQUIRE(p_median_dual_mesh != p_median_dual_mesh_rebuilt);
-    REQUIRE(p_median_dual_mesh.get() != p_median_dual_mesh_rebuilt.get());
+      REQUIRE(p_median_dual_mesh != p_diamond_dual_mesh);
 
-    // Exactly two references to the dual mesh. One here and
-    // one in the manager.
-    REQUIRE(p_median_dual_mesh_rebuilt.use_count() == 2);
+      REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
+      REQUIRE(p_median_dual_mesh.use_count() == median_ref_counter - 1);
+      REQUIRE(p_diamond_dual_mesh.use_count() == diamond_ref_counter - 1);
+    }
   }
 
-  SECTION("check multiple dual mesh using/freeing")
+  SECTION("3D")
   {
-    std::shared_ptr p_median_dual_mesh  = DualMeshManager::instance().getMedianDualMesh(*mesh);
-    std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+    using ConnectivityType = Connectivity<3>;
+    using MeshType         = Mesh<ConnectivityType>;
+
+    std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid3DMesh();
 
-    const auto median_ref_counter  = p_median_dual_mesh.use_count();
-    const auto diamond_ref_counter = p_diamond_dual_mesh.use_count();
+    SECTION("diamond dual mesh access")
+    {
+      std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+
+      const auto ref_counter = p_diamond_dual_mesh.use_count();
+
+      {
+        std::shared_ptr p_diamond_dual_mesh2 = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+
+        REQUIRE(p_diamond_dual_mesh == p_diamond_dual_mesh2);
+        REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter + 1);
+      }
 
-    REQUIRE(p_median_dual_mesh != p_diamond_dual_mesh);
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter);
 
-    REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
-    REQUIRE(p_median_dual_mesh.use_count() == median_ref_counter - 1);
-    REQUIRE(p_diamond_dual_mesh.use_count() == diamond_ref_counter - 1);
+      DualMeshManager::instance().deleteMesh(mesh.get());
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
+
+      // Can delete mesh from the list again. This means that no
+      // dual mesh associated with it is managed.
+      REQUIRE_NOTHROW(DualMeshManager::instance().deleteMesh(mesh.get()));
+      REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1);
+
+      // A new dual mesh is built
+      std::shared_ptr p_diamond_dual_mesh_rebuilt = DualMeshManager::instance().getDiamondDualMesh(*mesh);
+      REQUIRE(p_diamond_dual_mesh != p_diamond_dual_mesh_rebuilt);
+      REQUIRE(p_diamond_dual_mesh.get() != p_diamond_dual_mesh_rebuilt.get());
+
+      // Exactly two references to the dual mesh. One here and
+      // one in the manager.
+      REQUIRE(p_diamond_dual_mesh_rebuilt.use_count() == 2);
+    }
   }
 }