diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index 865238539b3fe4a0ba3e90326c33f39bfa54d683..f5ce39d5f7c67c448c327baf8fea9719d17021fd 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -48,7 +48,7 @@ class SubItemValuePerItem
   friend SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityWeakPtr>;
 
  public:
-  friend PUGS_INLINE SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityPtr>
+  [[nodiscard]] friend PUGS_INLINE SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityPtr>
   copy(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& source)
   {
     SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityPtr> image;
@@ -59,15 +59,13 @@ class SubItemValuePerItem
     return image;
   }
 
-  PUGS_INLINE
-  bool
+  [[nodiscard]] PUGS_INLINE bool
   isBuilt() const noexcept
   {
     return m_connectivity_ptr.use_count() != 0;
   }
 
-  PUGS_INLINE
-  std::shared_ptr<const IConnectivity>
+  [[nodiscard]] PUGS_INLINE std::shared_ptr<const IConnectivity>
   connectivity_ptr() const noexcept
   {
     if constexpr (std::is_same_v<ConnectivityPtr, ConnectivitySharedPtr>) {
@@ -78,18 +76,19 @@ class SubItemValuePerItem
   }
 
   template <typename IndexType, typename SubIndexType>
-  PUGS_FORCEINLINE DataType&
+  [[nodiscard]] PUGS_INLINE DataType&
   operator()(IndexType item_id, SubIndexType i) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "first index must be of the correct ItemId type");
     static_assert(std::is_integral_v<SubIndexType>, "second index must be an integral type");
-    Assert(this->isBuilt());
-    Assert(i + m_row_map[size_t{item_id}] < m_row_map[size_t{item_id} + 1]);
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
+    Assert(item_id < this->numberOfItems(), "invalid item_id");
+    Assert(i + m_row_map[size_t{item_id}] < m_row_map[size_t{item_id} + 1], "invalid index");
     return m_values[m_row_map[size_t{item_id}] + i];
   }
 
   template <ItemType item_t>
-  typename Array<DataType>::UnsafeArrayView
+  [[nodiscard]] PUGS_INLINE typename Array<DataType>::UnsafeArrayView
   operator[](const ItemIdT<item_t>& item_id) const noexcept(NO_ASSERT)
   {
     static_assert(item_t == item_type, "invalid ItemId type");
@@ -97,39 +96,37 @@ class SubItemValuePerItem
   }
 
   template <typename ArrayIndexType>
-  DataType&
+  [[nodiscard]] PUGS_INLINE DataType&
   operator[](const ArrayIndexType& i) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_integral_v<ArrayIndexType>, "index must be an integral type");
-    Assert(this->isBuilt());
-    Assert(static_cast<size_t>(i) < m_values.size());
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
+    Assert(static_cast<size_t>(i) < m_values.size(), "invalid index");
     return m_values[i];
   }
 
-  PUGS_INLINE
-  size_t
+  [[nodiscard]] PUGS_INLINE size_t
   numberOfValues() const noexcept(NO_ASSERT)
   {
-    Assert(this->isBuilt());
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
     return m_values.size();
   }
 
-  PUGS_INLINE
-  size_t
+  [[nodiscard]] PUGS_INLINE size_t
   numberOfItems() const noexcept(NO_ASSERT)
   {
-    Assert(this->isBuilt());
-    Assert(m_row_map.size() > 0);
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
+    Assert(m_row_map.size() > 0, "invalid row map");
     return m_row_map.size() - 1;
   }
 
   template <typename IndexType>
-  PUGS_INLINE size_t
+  [[nodiscard]] PUGS_INLINE size_t
   numberOfSubValues(IndexType item_id) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
-    Assert(this->isBuilt());
-    Assert(item_id < this->numberOfItems());
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
+    Assert(item_id < this->numberOfItems(), "invalid item_id");
     return m_row_map[size_t{item_id} + 1] - m_row_map[size_t{item_id}];
   }
 
@@ -142,12 +139,12 @@ class SubItemValuePerItem
   }
 
   template <typename IndexType>
-  PUGS_INLINE typename Array<DataType>::UnsafeArrayView
+  [[nodiscard]] PUGS_INLINE typename Array<DataType>::UnsafeArrayView
   itemArray(const IndexType& item_id) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
-    Assert(this->isBuilt());
-    Assert(item_id < this->numberOfItems());
+    Assert(this->isBuilt(), "SubItemValuePerItem is not built");
+    Assert(item_id < this->numberOfItems(), "invalid item_id");
     const auto& item_begin = m_row_map[size_t{item_id}];
     const auto& item_end   = m_row_map[size_t{item_id} + 1];
     return subArrayView(m_values, item_begin, item_end - item_begin);
@@ -198,6 +195,14 @@ class SubItemValuePerItem
     m_values  = Array<DataType>(connectivity_matrix.numberOfValues());
   }
 
+  SubItemValuePerItem(const IConnectivity& connectivity, const Array<DataType>& values) noexcept(NO_ASSERT)
+    : m_connectivity_ptr{connectivity.shared_ptr()}, m_values{values}
+  {
+    Assert(m_values.size() == connectivity.getMatrix(item_type, sub_item_type).numberOfValues(),
+           "invalid size of provided values");
+    m_row_map = connectivity.getMatrix(item_type, sub_item_type).rowsMap();
+  }
+
   ~SubItemValuePerItem() = default;
 };
 
diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp
index 8b0e8c5f41a3c238135e5a0c88ce15236ad67b8f..08d421fc1333ae8344402f9806446ab22c8de3b4 100644
--- a/tests/test_SubItemValuePerItem.cpp
+++ b/tests/test_SubItemValuePerItem.cpp
@@ -62,6 +62,15 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       return number;
     };
 
+    auto check_same_memory = [](const auto& sub_item_value_per_item, auto array) {
+      REQUIRE(sub_item_value_per_item.numberOfValues() == array.size());
+      bool is_same = true;
+      for (size_t i = 0; i < sub_item_value_per_item.numberOfValues(); ++i) {
+        is_same &= (&(sub_item_value_per_item[i]) == &(array[i]));
+      }
+      return is_same;
+    };
+
     SECTION("1D")
     {
       std::array mesh_list = MeshDataBaseForTests::get().all1DMeshes();
@@ -77,7 +86,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             NodeValuePerCell<int> node_value_per_cell{connectivity};
             REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
-            REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
+            const size_t nb_values = number_of_values(node_value_per_cell);
+            REQUIRE(node_value_per_cell.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            NodeValuePerCell<int> node_value_per_cell_from_array{connectivity, array};
+            REQUIRE(check_same_memory(node_value_per_cell_from_array, array));
 
             auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
             {
@@ -131,7 +145,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerFace<int> cell_value_per_face{connectivity};
             REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
-            REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
+            const size_t nb_values = number_of_values(cell_value_per_face);
+            REQUIRE(cell_value_per_face.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerFace<int> cell_value_per_face_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_face_from_array, array));
 
             auto face_to_cell_matrix = connectivity.faceToCellMatrix();
             {
@@ -147,7 +166,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerEdge<int> cell_value_per_edge{connectivity};
             REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
-            REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
+            const size_t nb_values = number_of_values(cell_value_per_edge);
+            REQUIRE(cell_value_per_edge.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerEdge<int> cell_value_per_edge_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_edge_from_array, array));
 
             auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
             {
@@ -163,7 +187,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerNode<int> cell_value_per_node{connectivity};
             REQUIRE(cell_value_per_node.numberOfItems() == connectivity.numberOfNodes());
-            REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node));
+            const size_t nb_values = number_of_values(cell_value_per_node);
+            REQUIRE(cell_value_per_node.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerNode<int> cell_value_per_node_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_node_from_array, array));
 
             auto node_to_cell_matrix = connectivity.nodeToCellMatrix();
             {
@@ -193,7 +222,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             NodeValuePerCell<int> node_value_per_cell{connectivity};
             REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
-            REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
+            const size_t nb_values = number_of_values(node_value_per_cell);
+            REQUIRE(node_value_per_cell.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            NodeValuePerCell<int> node_value_per_cell_from_array{connectivity, array};
+            REQUIRE(check_same_memory(node_value_per_cell_from_array, array));
 
             auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
             {
@@ -235,7 +269,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerFace<int> cell_value_per_face{connectivity};
             REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
-            REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
+            const size_t nb_values = number_of_values(cell_value_per_face);
+            REQUIRE(cell_value_per_face.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerFace<int> cell_value_per_face_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_face_from_array, array));
 
             auto face_to_cell_matrix = connectivity.faceToCellMatrix();
             {
@@ -264,7 +303,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerEdge<int> cell_value_per_edge{connectivity};
             REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
-            REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
+            const size_t nb_values = number_of_values(cell_value_per_edge);
+            REQUIRE(cell_value_per_edge.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerEdge<int> cell_value_per_edge_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_edge_from_array, array));
 
             auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
             {
@@ -293,7 +337,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             EdgeValuePerNode<int> edge_value_per_node{connectivity};
             REQUIRE(edge_value_per_node.numberOfItems() == connectivity.numberOfNodes());
-            REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node));
+            const size_t nb_values = number_of_values(edge_value_per_node);
+            REQUIRE(edge_value_per_node.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            EdgeValuePerNode<int> cell_value_per_node_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_node_from_array, array));
 
             auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix();
             {
@@ -349,7 +398,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             NodeValuePerCell<int> node_value_per_cell{connectivity};
             REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
-            REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
+            const size_t nb_values = number_of_values(node_value_per_cell);
+            REQUIRE(node_value_per_cell.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            NodeValuePerCell<int> node_value_per_cell_from_array{connectivity, array};
+            REQUIRE(check_same_memory(node_value_per_cell_from_array, array));
 
             auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
             {
@@ -391,7 +445,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerFace<int> cell_value_per_face{connectivity};
             REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
-            REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
+            const size_t nb_values = number_of_values(cell_value_per_face);
+            REQUIRE(cell_value_per_face.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerFace<int> cell_value_per_face_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_face_from_array, array));
 
             auto face_to_cell_matrix = connectivity.faceToCellMatrix();
             {
@@ -433,7 +492,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             CellValuePerEdge<int> cell_value_per_edge{connectivity};
             REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
-            REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
+            const size_t nb_values = number_of_values(cell_value_per_edge);
+            REQUIRE(cell_value_per_edge.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            CellValuePerEdge<int> cell_value_per_edge_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_edge_from_array, array));
 
             auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
             {
@@ -475,7 +539,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             EdgeValuePerNode<int> edge_value_per_node{connectivity};
             REQUIRE(edge_value_per_node.numberOfItems() == connectivity.numberOfNodes());
-            REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node));
+            const size_t nb_values = number_of_values(edge_value_per_node);
+            REQUIRE(edge_value_per_node.numberOfValues() == nb_values);
+
+            Array<int> array{nb_values};
+            EdgeValuePerNode<int> cell_value_per_node_from_array{connectivity, array};
+            REQUIRE(check_same_memory(cell_value_per_node_from_array, array));
 
             auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix();
             {
@@ -1312,40 +1381,57 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
     SECTION("checking for build SubItemValuePerItem")
     {
       CellValuePerNode<int> cell_value_per_node;
-      REQUIRE_THROWS_AS(cell_value_per_node[0], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node.itemArray(NodeId{0}), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node[NodeId{0}], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node(NodeId{0}, 0), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node.numberOfValues(), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node.numberOfItems(), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node.numberOfSubValues(NodeId{0}), AssertError);
+      REQUIRE_THROWS_WITH(cell_value_per_node[0], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node.itemArray(NodeId{0}), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node[NodeId{0}], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node(NodeId{0}, 0), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node.numberOfValues(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node.numberOfItems(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_node.numberOfSubValues(NodeId{0}), "SubItemValuePerItem is not built");
 
       FaceValuePerCell<int> face_value_per_cell;
-      REQUIRE_THROWS_AS(face_value_per_cell[0], AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell.itemArray(CellId{0}), AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell[CellId{0}], AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell(CellId{0}, 0), AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell.numberOfValues(), AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell.numberOfItems(), AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell.numberOfSubValues(CellId{0}), AssertError);
+      REQUIRE_THROWS_WITH(face_value_per_cell[0], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell.itemArray(CellId{0}), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell[CellId{0}], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell(CellId{0}, 0), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell.numberOfValues(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell.numberOfItems(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(face_value_per_cell.numberOfSubValues(CellId{0}), "SubItemValuePerItem is not built");
 
       CellValuePerEdge<int> cell_value_per_edge;
-      REQUIRE_THROWS_AS(cell_value_per_edge[0], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge.itemArray(EdgeId{0}), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge[EdgeId{0}], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge(EdgeId{0}, 0), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge.numberOfValues(), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge.numberOfItems(), AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge.numberOfSubValues(EdgeId{0}), AssertError);
+      REQUIRE_THROWS_WITH(cell_value_per_edge[0], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge.itemArray(EdgeId{0}), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge[EdgeId{0}], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge(EdgeId{0}, 0), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge.numberOfValues(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge.numberOfItems(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(cell_value_per_edge.numberOfSubValues(EdgeId{0}), "SubItemValuePerItem is not built");
 
       NodeValuePerFace<int> node_value_per_face;
-      REQUIRE_THROWS_AS(node_value_per_face[0], AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face.itemArray(FaceId{0}), AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face[FaceId{0}], AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face(FaceId{0}, 0), AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face.numberOfValues(), AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face.numberOfItems(), AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face.numberOfSubValues(FaceId{0}), AssertError);
+      REQUIRE_THROWS_WITH(node_value_per_face[0], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face.itemArray(FaceId{0}), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face[FaceId{0}], "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face(FaceId{0}, 0), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face.numberOfValues(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face.numberOfItems(), "SubItemValuePerItem is not built");
+      REQUIRE_THROWS_WITH(node_value_per_face.numberOfSubValues(FaceId{0}), "SubItemValuePerItem is not built");
+    }
+
+    SECTION("checking invalid array size in constructor")
+    {
+      auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh();
+
+      const Connectivity<3>& connectivity = mesh_3d->connectivity();
+
+      {
+        Array<int> array{connectivity.getMatrix(ItemType::node, ItemType::cell).numberOfValues() + 3};
+        REQUIRE_THROWS_WITH(CellValuePerNode<int>(connectivity, array), "invalid size of provided values");
+      }
+
+      {
+        Array<int> array{connectivity.getMatrix(ItemType::face, ItemType::edge).numberOfValues() + 3};
+        REQUIRE_THROWS_WITH(EdgeValuePerFace<int>(connectivity, array), "invalid size of provided values");
+      }
     }
 
     SECTION("checking for bounds violation")
@@ -1362,57 +1448,61 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           CellValuePerFace<int> cell_value_per_face{connectivity};
           {
             FaceId invalid_face_id = connectivity.numberOfFaces();
-            REQUIRE_THROWS_AS(cell_value_per_face(invalid_face_id, 0), AssertError);
+            REQUIRE_THROWS_WITH(cell_value_per_face(invalid_face_id, 0), "invalid item_id");
+            REQUIRE_THROWS_WITH(cell_value_per_face[invalid_face_id], "invalid item_id");
           }
           if (connectivity.numberOfFaces() > 0) {
             FaceId face_id          = 0;
             const auto& cell_values = cell_value_per_face.itemArray(face_id);
-            REQUIRE_THROWS_AS(cell_value_per_face(face_id, cell_values.size()), AssertError);
-            REQUIRE_THROWS_AS(cell_values[cell_values.size()], AssertError);
-            REQUIRE_THROWS_AS(cell_value_per_face.itemArray(face_id)[cell_values.size()] = 2, AssertError);
-            REQUIRE_THROWS_AS(cell_value_per_face[face_id][cell_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_WITH(cell_value_per_face(face_id, cell_values.size()), "invalid index");
+            REQUIRE_THROWS_WITH(cell_values[cell_values.size()], "invalid index");
+            REQUIRE_THROWS_WITH(cell_value_per_face.itemArray(face_id)[cell_values.size()] = 2, "invalid index");
+            REQUIRE_THROWS_WITH(cell_value_per_face[face_id][cell_values.size()] = 2, "invalid index");
           }
 
           FaceValuePerNode<int> face_value_per_node{connectivity};
           {
             NodeId invalid_node_id = connectivity.numberOfNodes();
-            REQUIRE_THROWS_AS(face_value_per_node(invalid_node_id, 0), AssertError);
+            REQUIRE_THROWS_WITH(face_value_per_node(invalid_node_id, 0), "invalid item_id");
+            REQUIRE_THROWS_WITH(face_value_per_node[invalid_node_id], "invalid item_id");
           }
           if (connectivity.numberOfNodes() > 0) {
             NodeId node_id          = 0;
             const auto& face_values = face_value_per_node.itemArray(node_id);
-            REQUIRE_THROWS_AS(face_value_per_node(node_id, face_values.size()), AssertError);
-            REQUIRE_THROWS_AS(face_values[face_values.size()], AssertError);
-            REQUIRE_THROWS_AS(face_value_per_node.itemArray(node_id)[face_values.size()] = 2, AssertError);
-            REQUIRE_THROWS_AS(face_value_per_node[node_id][face_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_WITH(face_value_per_node(node_id, face_values.size()), "invalid index");
+            REQUIRE_THROWS_WITH(face_values[face_values.size()], "invalid index");
+            REQUIRE_THROWS_WITH(face_value_per_node.itemArray(node_id)[face_values.size()] = 2, "invalid index");
+            REQUIRE_THROWS_WITH(face_value_per_node[node_id][face_values.size()] = 2, "invalid index");
           }
 
           EdgeValuePerCell<int> edge_value_per_cell{connectivity};
           {
             CellId invalid_cell_id = connectivity.numberOfCells();
-            REQUIRE_THROWS_AS(edge_value_per_cell(invalid_cell_id, 0), AssertError);
+            REQUIRE_THROWS_WITH(edge_value_per_cell(invalid_cell_id, 0), "invalid item_id");
+            REQUIRE_THROWS_WITH(edge_value_per_cell[invalid_cell_id], "invalid item_id");
           }
           if (connectivity.numberOfCells() > 0) {
             CellId cell_id          = 0;
             const auto& edge_values = edge_value_per_cell.itemArray(cell_id);
-            REQUIRE_THROWS_AS(edge_value_per_cell(cell_id, edge_values.size()), AssertError);
-            REQUIRE_THROWS_AS(edge_values[edge_values.size()], AssertError);
-            REQUIRE_THROWS_AS(edge_value_per_cell.itemArray(cell_id)[edge_values.size()] = 2, AssertError);
-            REQUIRE_THROWS_AS(edge_value_per_cell[cell_id][edge_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_WITH(edge_value_per_cell(cell_id, edge_values.size()), "invalid index");
+            REQUIRE_THROWS_WITH(edge_values[edge_values.size()], "invalid index");
+            REQUIRE_THROWS_WITH(edge_value_per_cell.itemArray(cell_id)[edge_values.size()] = 2, "invalid index");
+            REQUIRE_THROWS_WITH(edge_value_per_cell[cell_id][edge_values.size()] = 2, "invalid index");
           }
 
           NodeValuePerEdge<int> node_value_per_edge{connectivity};
           {
             EdgeId invalid_edge_id = connectivity.numberOfEdges();
-            REQUIRE_THROWS_AS(node_value_per_edge(invalid_edge_id, 0), AssertError);
+            REQUIRE_THROWS_WITH(node_value_per_edge(invalid_edge_id, 0), "invalid item_id");
+            REQUIRE_THROWS_WITH(node_value_per_edge[invalid_edge_id], "invalid item_id");
           }
           if (connectivity.numberOfEdges() > 0) {
             EdgeId edge_id          = 0;
             const auto& node_values = node_value_per_edge.itemArray(edge_id);
-            REQUIRE_THROWS_AS(node_value_per_edge(edge_id, node_values.size()), AssertError);
-            REQUIRE_THROWS_AS(node_values[node_values.size()], AssertError);
-            REQUIRE_THROWS_AS(node_value_per_edge.itemArray(edge_id)[node_values.size()] = 2, AssertError);
-            REQUIRE_THROWS_AS(node_value_per_edge[edge_id][node_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_WITH(node_value_per_edge(edge_id, node_values.size()), "invalid index");
+            REQUIRE_THROWS_WITH(node_values[node_values.size()], "invalid index");
+            REQUIRE_THROWS_WITH(node_value_per_edge.itemArray(edge_id)[node_values.size()] = 2, "invalid index");
+            REQUIRE_THROWS_WITH(node_value_per_edge[edge_id][node_values.size()] = 2, "invalid index");
           }
         }
       }