Reorganize tests and add missing ones

Now tests all item types of ItemArray, but due to the template
structure of the code, these tests where not really missing.

tests/test_Synchronizer.cpp

@@ -11,6 +11,8 @@
 // clazy:excludeall=non-pod-global-static
 
 TEST_CASE("Synchronizer", "[mesh]")
+{
+  SECTION("ItemValue")
   {
     auto is_same_item_value = [](auto a, auto b) {
       using IndexT = typename decltype(a)::index_type;
@@ -21,17 +23,6 @@ TEST_CASE("Synchronizer", "[mesh]")
       return parallel::allReduceAnd(is_same);
     };
 
-  auto is_same_item_array = [](auto a, auto b) {
-    using IndexT = typename decltype(a)::index_type;
-    bool is_same = true;
-    for (IndexT i = 0; i < a.numberOfItems(); ++i) {
-      for (size_t j = 0; j < a.sizeOfArrays(); ++j) {
-        is_same &= (a[i][j] == b[i][j]);
-      }
-    }
-    return parallel::allReduceAnd(is_same);
-  };
-
     SECTION("1D")
     {
       constexpr size_t Dimension = 1;
@@ -138,37 +129,6 @@ TEST_CASE("Synchronizer", "[mesh]")
 
         REQUIRE(is_same_item_value(cell_value, cell_value_ref));
       }
-
-    SECTION("synchonize CellArray")
-    {
-      const auto cell_owner  = connectivity.cellOwner();
-      const auto cell_number = connectivity.cellNumber();
-
-      CellArray<int> cell_array_ref{connectivity, 3};
-      parallel_for(
-        connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
-          for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
-            cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
-          }
-        });
-
-      CellArray<int> cell_array{connectivity, 3};
-      parallel_for(
-        connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
-          for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
-            cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
-          }
-        });
-
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
-      }
-
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_array);
-
-      REQUIRE(is_same_item_array(cell_array, cell_array_ref));
-    }
     }
 
     SECTION("2D")
@@ -277,37 +237,6 @@ TEST_CASE("Synchronizer", "[mesh]")
 
         REQUIRE(is_same_item_value(cell_value, cell_value_ref));
       }
-
-    SECTION("synchonize CellArray")
-    {
-      const auto cell_owner  = connectivity.cellOwner();
-      const auto cell_number = connectivity.cellNumber();
-
-      CellArray<int> cell_array_ref{connectivity, 3};
-      parallel_for(
-        connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
-          for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
-            cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
-          }
-        });
-
-      CellArray<int> cell_array{connectivity, 3};
-      parallel_for(
-        connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
-          for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
-            cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
-          }
-        });
-
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
-      }
-
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_array);
-
-      REQUIRE(is_same_item_array(cell_array, cell_array_ref));
-    }
     }
 
     SECTION("3D")
@@ -416,6 +345,121 @@ TEST_CASE("Synchronizer", "[mesh]")
 
         REQUIRE(is_same_item_value(cell_value, cell_value_ref));
       }
+    }
+  }
+
+  SECTION("ItemArray")
+  {
+    auto is_same_item_array = [](auto a, auto b) {
+      using IndexT = typename decltype(a)::index_type;
+      bool is_same = true;
+      for (IndexT i = 0; i < a.numberOfItems(); ++i) {
+        for (size_t j = 0; j < a.sizeOfArrays(); ++j) {
+          is_same &= (a[i][j] == b[i][j]);
+        }
+      }
+      return parallel::allReduceAnd(is_same);
+    };
+
+    SECTION("1D")
+    {
+      constexpr size_t Dimension = 1;
+      using ConnectivityType     = Connectivity<Dimension>;
+
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
+
+      SECTION("synchonize NodeArray")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
+
+        NodeArray<int> node_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+              node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+            }
+          });
+
+        NodeArray<int> node_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+              node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(node_array, node_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_array);
+
+        REQUIRE(is_same_item_array(node_array, node_array_ref));
+      }
+
+      SECTION("synchonize EdgeArray")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
+
+        EdgeArray<int> edge_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+              edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+            }
+          });
+
+        EdgeArray<int> edge_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+              edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_array);
+
+        REQUIRE(is_same_item_array(edge_array, edge_array_ref));
+      }
+
+      SECTION("synchonize FaceArray")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
+
+        FaceArray<int> face_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+              face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+            }
+          });
+
+        FaceArray<int> face_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+              face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(face_array, face_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_array);
+
+        REQUIRE(is_same_item_array(face_array, face_array_ref));
+      }
 
       SECTION("synchonize CellArray")
       {
@@ -448,4 +492,269 @@ TEST_CASE("Synchronizer", "[mesh]")
         REQUIRE(is_same_item_array(cell_array, cell_array_ref));
       }
     }
+
+    SECTION("2D")
+    {
+      constexpr size_t Dimension = 2;
+      using ConnectivityType     = Connectivity<Dimension>;
+
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
+
+      SECTION("synchonize NodeArray")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
+
+        NodeArray<int> node_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+              node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+            }
+          });
+
+        NodeArray<int> node_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+              node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(node_array, node_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_array);
+
+        REQUIRE(is_same_item_array(node_array, node_array_ref));
+      }
+
+      SECTION("synchonize EdgeArray")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
+
+        EdgeArray<int> edge_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+              edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+            }
+          });
+
+        EdgeArray<int> edge_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+              edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_array);
+
+        REQUIRE(is_same_item_array(edge_array, edge_array_ref));
+      }
+
+      SECTION("synchonize FaceArray")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
+
+        FaceArray<int> face_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+              face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+            }
+          });
+
+        FaceArray<int> face_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+              face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(face_array, face_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_array);
+
+        REQUIRE(is_same_item_array(face_array, face_array_ref));
+      }
+
+      SECTION("synchonize CellArray")
+      {
+        const auto cell_owner  = connectivity.cellOwner();
+        const auto cell_number = connectivity.cellNumber();
+
+        CellArray<int> cell_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
+            for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
+              cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
+            }
+          });
+
+        CellArray<int> cell_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
+            for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
+              cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(cell_array);
+
+        REQUIRE(is_same_item_array(cell_array, cell_array_ref));
+      }
+    }
+
+    SECTION("3D")
+    {
+      constexpr size_t Dimension = 3;
+      using ConnectivityType     = Connectivity<Dimension>;
+
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
+
+      SECTION("synchonize NodeArray")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
+
+        NodeArray<int> node_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+              node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+            }
+          });
+
+        NodeArray<int> node_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+            for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+              node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(node_array, node_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_array);
+
+        REQUIRE(is_same_item_array(node_array, node_array_ref));
+      }
+
+      SECTION("synchonize EdgeArray")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
+
+        EdgeArray<int> edge_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+              edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+            }
+          });
+
+        EdgeArray<int> edge_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+            for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+              edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_array);
+
+        REQUIRE(is_same_item_array(edge_array, edge_array_ref));
+      }
+
+      SECTION("synchonize FaceArray")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
+
+        FaceArray<int> face_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+              face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+            }
+          });
+
+        FaceArray<int> face_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+            for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+              face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(face_array, face_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_array);
+
+        REQUIRE(is_same_item_array(face_array, face_array_ref));
+      }
+
+      SECTION("synchonize CellArray")
+      {
+        const auto cell_owner  = connectivity.cellOwner();
+        const auto cell_number = connectivity.cellNumber();
+
+        CellArray<int> cell_array_ref{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
+            for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
+              cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
+            }
+          });
+
+        CellArray<int> cell_array{connectivity, 3};
+        parallel_for(
+          connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
+            for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
+              cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
+            }
+          });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(cell_array);
+
+        REQUIRE(is_same_item_array(cell_array, cell_array_ref));
+      }
+    }
+  }
 }