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"); } } }