diff --git a/tests/test_Synchronizer.cpp b/tests/test_Synchronizer.cpp
index 8cc0ea66115d26271be227771547442864ada459..29f2fbac50c20180ce048557e38c961f2b700513 100644
--- a/tests/test_Synchronizer.cpp
+++ b/tests/test_Synchronizer.cpp
@@ -12,440 +12,749 @@
 
 TEST_CASE("Synchronizer", "[mesh]")
 {
-  auto is_same_item_value = [](auto a, auto b) {
-    using IndexT = typename decltype(a)::index_type;
-    bool is_same = true;
-    for (IndexT i = 0; i < a.numberOfItems(); ++i) {
-      is_same &= (a[i] == b[i]);
-    }
-    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]);
+  SECTION("ItemValue")
+  {
+    auto is_same_item_value = [](auto a, auto b) {
+      using IndexT = typename decltype(a)::index_type;
+      bool is_same = true;
+      for (IndexT i = 0; i < a.numberOfItems(); ++i) {
+        is_same &= (a[i] == b[i]);
       }
-    }
-    return parallel::allReduceAnd(is_same);
-  };
+      return parallel::allReduceAnd(is_same);
+    };
 
-  SECTION("1D")
-  {
-    constexpr size_t Dimension = 1;
-    using ConnectivityType     = Connectivity<Dimension>;
+    SECTION("1D")
+    {
+      constexpr size_t Dimension = 1;
+      using ConnectivityType     = Connectivity<Dimension>;
 
-    const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
 
-    SECTION("synchonize NodeValue")
-    {
-      const auto node_owner  = connectivity.nodeOwner();
-      const auto node_number = connectivity.nodeNumber();
+      SECTION("synchonize NodeValue")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
+
+        NodeValue<int> node_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
+
+        NodeValue<int> node_value{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
 
-      NodeValue<int> node_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        }
 
-      NodeValue<int> node_value{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        REQUIRE(is_same_item_value(node_value, node_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(node_value);
+      SECTION("synchonize EdgeValue")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
 
-      REQUIRE(is_same_item_value(node_value, node_value_ref));
-    }
+        EdgeValue<int> edge_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
 
-    SECTION("synchonize EdgeValue")
-    {
-      const auto edge_owner  = connectivity.edgeOwner();
-      const auto edge_number = connectivity.edgeNumber();
+        EdgeValue<int> edge_value{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
 
-      EdgeValue<int> edge_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        }
 
-      EdgeValue<int> edge_value{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        REQUIRE(is_same_item_value(edge_value, edge_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(edge_value);
+      SECTION("synchonize FaceValue")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
 
-      REQUIRE(is_same_item_value(edge_value, edge_value_ref));
-    }
+        FaceValue<int> face_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
 
-    SECTION("synchonize FaceValue")
-    {
-      const auto face_owner  = connectivity.faceOwner();
-      const auto face_number = connectivity.faceNumber();
+        FaceValue<int> face_value{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
 
-      FaceValue<int> face_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        }
 
-      FaceValue<int> face_value{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        REQUIRE(is_same_item_value(face_value, face_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(face_value);
+      SECTION("synchonize CellValue")
+      {
+        const auto cell_owner  = connectivity.cellOwner();
+        const auto cell_number = connectivity.cellNumber();
 
-      REQUIRE(is_same_item_value(face_value, face_value_ref));
-    }
+        CellValue<int> cell_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
 
-    SECTION("synchonize CellValue")
-    {
-      const auto cell_owner  = connectivity.cellOwner();
-      const auto cell_number = connectivity.cellNumber();
+        CellValue<int> cell_value{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
 
-      CellValue<int> cell_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+        }
 
-      CellValue<int> cell_value{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(cell_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+        REQUIRE(is_same_item_value(cell_value, cell_value_ref));
       }
-
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_value);
-
-      REQUIRE(is_same_item_value(cell_value, cell_value_ref));
     }
 
-    SECTION("synchonize CellArray")
+    SECTION("2D")
     {
-      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);
+      constexpr size_t Dimension = 2;
+      using ConnectivityType     = Connectivity<Dimension>;
 
-      REQUIRE(is_same_item_array(cell_array, cell_array_ref));
-    }
-  }
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
 
-  SECTION("2D")
-  {
-    constexpr size_t Dimension = 2;
-    using ConnectivityType     = Connectivity<Dimension>;
+      SECTION("synchonize NodeValue")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
 
-    const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
+        NodeValue<int> node_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
 
-    SECTION("synchonize NodeValue")
-    {
-      const auto node_owner  = connectivity.nodeOwner();
-      const auto node_number = connectivity.nodeNumber();
+        NodeValue<int> node_value{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
 
-      NodeValue<int> node_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        }
 
-      NodeValue<int> node_value{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        REQUIRE(is_same_item_value(node_value, node_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(node_value);
+      SECTION("synchonize EdgeValue")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
 
-      REQUIRE(is_same_item_value(node_value, node_value_ref));
-    }
+        EdgeValue<int> edge_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
 
-    SECTION("synchonize EdgeValue")
-    {
-      const auto edge_owner  = connectivity.edgeOwner();
-      const auto edge_number = connectivity.edgeNumber();
+        EdgeValue<int> edge_value{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
 
-      EdgeValue<int> edge_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        }
 
-      EdgeValue<int> edge_value{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        REQUIRE(is_same_item_value(edge_value, edge_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(edge_value);
+      SECTION("synchonize FaceValue")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
 
-      REQUIRE(is_same_item_value(edge_value, edge_value_ref));
-    }
+        FaceValue<int> face_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
 
-    SECTION("synchonize FaceValue")
-    {
-      const auto face_owner  = connectivity.faceOwner();
-      const auto face_number = connectivity.faceNumber();
+        FaceValue<int> face_value{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
 
-      FaceValue<int> face_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        }
 
-      FaceValue<int> face_value{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        REQUIRE(is_same_item_value(face_value, face_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(face_value);
+      SECTION("synchonize CellValue")
+      {
+        const auto cell_owner  = connectivity.cellOwner();
+        const auto cell_number = connectivity.cellNumber();
 
-      REQUIRE(is_same_item_value(face_value, face_value_ref));
-    }
+        CellValue<int> cell_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
 
-    SECTION("synchonize CellValue")
-    {
-      const auto cell_owner  = connectivity.cellOwner();
-      const auto cell_number = connectivity.cellNumber();
+        CellValue<int> cell_value{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
 
-      CellValue<int> cell_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+        }
 
-      CellValue<int> cell_value{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(cell_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+        REQUIRE(is_same_item_value(cell_value, cell_value_ref));
       }
-
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_value);
-
-      REQUIRE(is_same_item_value(cell_value, cell_value_ref));
     }
 
-    SECTION("synchonize CellArray")
+    SECTION("3D")
     {
-      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);
+      constexpr size_t Dimension = 3;
+      using ConnectivityType     = Connectivity<Dimension>;
 
-      REQUIRE(is_same_item_array(cell_array, cell_array_ref));
-    }
-  }
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
 
-  SECTION("3D")
-  {
-    constexpr size_t Dimension = 3;
-    using ConnectivityType     = Connectivity<Dimension>;
+      SECTION("synchonize NodeValue")
+      {
+        const auto node_owner  = connectivity.nodeOwner();
+        const auto node_number = connectivity.nodeNumber();
 
-    const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
+        NodeValue<int> node_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
 
-    SECTION("synchonize NodeValue")
-    {
-      const auto node_owner  = connectivity.nodeOwner();
-      const auto node_number = connectivity.nodeNumber();
+        NodeValue<int> node_value{connectivity};
+        parallel_for(
+          connectivity.numberOfNodes(),
+          PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
 
-      NodeValue<int> node_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        }
 
-      NodeValue<int> node_value{connectivity};
-      parallel_for(
-        connectivity.numberOfNodes(),
-        PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(node_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(node_value, node_value_ref));
+        REQUIRE(is_same_item_value(node_value, node_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(node_value);
+      SECTION("synchonize EdgeValue")
+      {
+        const auto edge_owner  = connectivity.edgeOwner();
+        const auto edge_number = connectivity.edgeNumber();
 
-      REQUIRE(is_same_item_value(node_value, node_value_ref));
-    }
+        EdgeValue<int> edge_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
 
-    SECTION("synchonize EdgeValue")
-    {
-      const auto edge_owner  = connectivity.edgeOwner();
-      const auto edge_number = connectivity.edgeNumber();
+        EdgeValue<int> edge_value{connectivity};
+        parallel_for(
+          connectivity.numberOfEdges(),
+          PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
 
-      EdgeValue<int> edge_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        }
 
-      EdgeValue<int> edge_value{connectivity};
-      parallel_for(
-        connectivity.numberOfEdges(),
-        PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(edge_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+        REQUIRE(is_same_item_value(edge_value, edge_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(edge_value);
+      SECTION("synchonize FaceValue")
+      {
+        const auto face_owner  = connectivity.faceOwner();
+        const auto face_number = connectivity.faceNumber();
 
-      REQUIRE(is_same_item_value(edge_value, edge_value_ref));
-    }
+        FaceValue<int> face_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
 
-    SECTION("synchonize FaceValue")
-    {
-      const auto face_owner  = connectivity.faceOwner();
-      const auto face_number = connectivity.faceNumber();
+        FaceValue<int> face_value{connectivity};
+        parallel_for(
+          connectivity.numberOfFaces(),
+          PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
 
-      FaceValue<int> face_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        }
 
-      FaceValue<int> face_value{connectivity};
-      parallel_for(
-        connectivity.numberOfFaces(),
-        PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(face_value);
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(face_value, face_value_ref));
+        REQUIRE(is_same_item_value(face_value, face_value_ref));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(face_value);
+      SECTION("synchonize CellValue")
+      {
+        const auto cell_owner  = connectivity.cellOwner();
+        const auto cell_number = connectivity.cellNumber();
 
-      REQUIRE(is_same_item_value(face_value, face_value_ref));
+        CellValue<int> cell_value_ref{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
+
+        CellValue<int> cell_value{connectivity};
+        parallel_for(
+          connectivity.numberOfCells(),
+          PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
+
+        if (parallel::size() > 1) {
+          REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+        }
+
+        Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+        synchronizer.synchronize(cell_value);
+
+        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("synchonize CellValue")
+    SECTION("1D")
     {
-      const auto cell_owner  = connectivity.cellOwner();
-      const auto cell_number = connectivity.cellNumber();
+      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));
+      }
 
-      CellValue<int> cell_value_ref{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
+      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));
+      }
+    }
 
-      CellValue<int> cell_value{connectivity};
-      parallel_for(
-        connectivity.numberOfCells(),
-        PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
+    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));
+      }
 
-      if (parallel::size() > 1) {
-        REQUIRE(not is_same_item_value(cell_value, cell_value_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));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_value);
+      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));
+      }
 
-      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("synchonize CellArray")
+    SECTION("3D")
     {
-      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));
+      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));
       }
 
-      Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
-      synchronizer.synchronize(cell_array);
+      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));
+      }
 
-      REQUIRE(is_same_item_array(cell_array, cell_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));
+      }
     }
   }
 }