From d6fc7ca79f109a6c2667e23c525faadf236016e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com> Date: Tue, 6 Apr 2021 15:07:36 +0200 Subject: [PATCH] Add bound checking assertions Also add access to the connectivity pointer --- src/mesh/SubItemValuePerItem.hpp | 14 +- tests/test_SubItemValuePerItem.cpp | 430 ++++++++++++++++++++--------- 2 files changed, 316 insertions(+), 128 deletions(-) diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp index 170ffd76d..dedafdb9c 100644 --- a/src/mesh/SubItemValuePerItem.hpp +++ b/src/mesh/SubItemValuePerItem.hpp @@ -109,6 +109,17 @@ class SubItemValuePerItem return m_connectivity_ptr.use_count() != 0; } + PUGS_INLINE + std::shared_ptr<const IConnectivity> + connectivity_ptr() const noexcept + { + if constexpr (std::is_same_v<ConnectivityPtr, ConnectivitySharedPtr>) { + return m_connectivity_ptr; + } else { + return m_connectivity_ptr.lock(); + } + } + template <typename IndexType, typename SubIndexType> PUGS_FORCEINLINE DataType& operator()(IndexType item_id, SubIndexType i) const noexcept(NO_ASSERT) @@ -128,7 +139,7 @@ class SubItemValuePerItem { static_assert(std::is_integral_v<ArrayIndexType>, "index must be an integral type"); Assert(this->isBuilt()); - Assert(i < m_values.size()); + Assert(static_cast<size_t>(i) < m_values.size()); return m_values[i]; } @@ -223,7 +234,6 @@ class SubItemValuePerItem { static_assert(not std::is_const_v<DataType>, "Cannot allocate SubItemValuePerItem of const data: only " "view is supported"); - ; ConnectivityMatrix connectivity_matrix = connectivity._getMatrix(item_type, sub_item_type); diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp index b7549c444..15c070ddd 100644 --- a/tests/test_SubItemValuePerItem.cpp +++ b/tests/test_SubItemValuePerItem.cpp @@ -74,15 +74,24 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell)); auto cell_to_node_matrix = connectivity.cellToNodeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)); - REQUIRE(node_value_per_cell.itemValues(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= + (cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)) and + (node_value_per_cell.itemValues(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } const NodeValuePerCell<const int> const_node_value_per_cell = node_value_per_cell; - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(const_node_value_per_cell.itemValues(cell_id).size() == - node_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= + (const_node_value_per_cell.itemValues(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } EdgeValuePerCell<int> edge_value_per_cell{connectivity}; @@ -90,8 +99,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell)); auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } FaceValuePerCell<int> face_value_per_cell{connectivity}; @@ -99,8 +112,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell)); auto cell_to_face_matrix = connectivity.cellToFaceMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } } @@ -111,8 +128,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face)); auto face_to_cell_matrix = connectivity.faceToCellMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } } @@ -123,8 +144,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge)); auto edge_to_cell_matrix = connectivity.edgeToCellMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } } @@ -135,8 +160,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node)); auto node_to_cell_matrix = connectivity.nodeToCellMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } } } @@ -153,8 +182,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell)); auto cell_to_node_matrix = connectivity.cellToNodeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } EdgeValuePerCell<int> edge_value_per_cell{connectivity}; @@ -162,8 +195,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell)); auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } FaceValuePerCell<int> face_value_per_cell{connectivity}; @@ -171,8 +208,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell)); auto cell_to_face_matrix = connectivity.cellToFaceMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } } @@ -183,8 +224,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face)); auto face_to_cell_matrix = connectivity.faceToCellMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } NodeValuePerFace<int> node_value_per_face{connectivity}; @@ -192,8 +237,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_face.numberOfValues() == number_of_values(node_value_per_face)); auto face_to_node_matrix = connectivity.faceToNodeMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } } @@ -204,8 +253,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge)); auto edge_to_cell_matrix = connectivity.edgeToCellMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } NodeValuePerEdge<int> node_value_per_edge{connectivity}; @@ -213,8 +266,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_edge.numberOfValues() == number_of_values(node_value_per_edge)); auto edge_to_node_matrix = connectivity.edgeToNodeMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } } @@ -225,8 +282,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node)); auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } FaceValuePerNode<int> face_value_per_node{connectivity}; @@ -234,8 +295,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_node.numberOfValues() == number_of_values(face_value_per_node)); auto node_to_face_matrix = connectivity.nodeToFaceMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } CellValuePerNode<int> cell_value_per_node{connectivity}; @@ -243,8 +308,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node)); auto node_to_cell_matrix = connectivity.nodeToCellMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } } } @@ -261,8 +330,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell)); auto cell_to_node_matrix = connectivity.cellToNodeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } EdgeValuePerCell<int> edge_value_per_cell{connectivity}; @@ -270,8 +343,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell)); auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } FaceValuePerCell<int> face_value_per_cell{connectivity}; @@ -279,8 +356,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell)); auto cell_to_face_matrix = connectivity.cellToFaceMatrix(); - for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { - REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + { + bool is_correct = true; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + is_correct &= (cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id)); + } + REQUIRE(is_correct); } } @@ -291,8 +372,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face)); auto face_to_cell_matrix = connectivity.faceToCellMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } EdgeValuePerFace<int> edge_value_per_face{connectivity}; @@ -300,8 +385,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_face.numberOfValues() == number_of_values(edge_value_per_face)); auto face_to_edge_matrix = connectivity.faceToEdgeMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_edge_matrix[face_id].size() == edge_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_edge_matrix[face_id].size() == edge_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } NodeValuePerFace<int> node_value_per_face{connectivity}; @@ -309,8 +398,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_face.numberOfValues() == number_of_values(node_value_per_face)); auto face_to_node_matrix = connectivity.faceToNodeMatrix(); - for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - REQUIRE(face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id)); + { + bool is_correct = true; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + is_correct &= (face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id)); + } + REQUIRE(is_correct); } } @@ -321,8 +414,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge)); auto edge_to_cell_matrix = connectivity.edgeToCellMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } FaceValuePerEdge<int> face_value_per_edge{connectivity}; @@ -330,8 +427,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_edge.numberOfValues() == number_of_values(face_value_per_edge)); auto edge_to_face_matrix = connectivity.edgeToFaceMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_face_matrix[edge_id].size() == face_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_face_matrix[edge_id].size() == face_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } NodeValuePerEdge<int> node_value_per_edge{connectivity}; @@ -339,8 +440,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(node_value_per_edge.numberOfValues() == number_of_values(node_value_per_edge)); auto edge_to_node_matrix = connectivity.edgeToNodeMatrix(); - for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { - REQUIRE(edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id)); + { + bool is_correct = true; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + is_correct &= (edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id)); + } + REQUIRE(is_correct); } } @@ -351,8 +456,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node)); auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } FaceValuePerNode<int> face_value_per_node{connectivity}; @@ -360,8 +469,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(face_value_per_node.numberOfValues() == number_of_values(face_value_per_node)); auto node_to_face_matrix = connectivity.nodeToFaceMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } CellValuePerNode<int> cell_value_per_node{connectivity}; @@ -369,8 +482,12 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node)); auto node_to_cell_matrix = connectivity.nodeToCellMatrix(); - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + { + bool is_correct = true; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + is_correct &= (node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id)); + } + REQUIRE(is_correct); } } } @@ -392,20 +509,26 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") } } } - for (size_t i = 0; i < edge_values_per_cell.numberOfValues(); ++i) { - REQUIRE(edge_values_per_cell[i] == i); + { + bool is_same = true; + for (size_t i = 0; i < edge_values_per_cell.numberOfValues(); ++i) { + is_same &= (edge_values_per_cell[i] == i); + } + REQUIRE(is_same); } for (size_t i = 0; i < edge_values_per_cell.numberOfValues(); ++i) { edge_values_per_cell[i] = i * i + 1; } { - size_t i = 0; + bool is_same = true; + size_t i = 0; for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { for (size_t i_edge = 0; i_edge < edge_values_per_cell.numberOfSubValues(cell_id); ++i_edge, ++i) { - REQUIRE(edge_values_per_cell(cell_id, i_edge) == i * i + 1); + is_same &= (edge_values_per_cell(cell_id, i_edge) == i * i + 1); } } + REQUIRE(is_same); } } @@ -423,20 +546,25 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") } } } - for (size_t i = 0; i < cell_values_per_face.numberOfValues(); ++i) { - REQUIRE(cell_values_per_face[i] == i); + { + bool is_same = true; + for (size_t i = 0; i < cell_values_per_face.numberOfValues(); ++i) { + is_same &= (cell_values_per_face[i] == i); + } + REQUIRE(is_same); } - for (size_t i = 0; i < cell_values_per_face.numberOfValues(); ++i) { cell_values_per_face[i] = 3 * i + 1; } { - size_t i = 0; + bool is_same = true; + size_t i = 0; for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { for (size_t i_cell = 0; i_cell < cell_values_per_face.numberOfSubValues(face_id); ++i_cell, ++i) { - REQUIRE(cell_values_per_face(face_id, i_cell) == 3 * i + 1); + is_same &= (cell_values_per_face(face_id, i_cell) == 3 * i + 1); } } + REQUIRE(is_same); } } @@ -454,29 +582,26 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") } } } - for (size_t i = 0; i < face_values_per_node.numberOfValues(); ++i) { - REQUIRE(face_values_per_node[i] == i); + { + bool is_same = true; + for (size_t i = 0; i < face_values_per_node.numberOfValues(); ++i) { + is_same &= (face_values_per_node[i] == i); + } + REQUIRE(is_same); } for (size_t i = 0; i < face_values_per_node.numberOfValues(); ++i) { face_values_per_node[i] = 3 + i * i; } { - size_t i = 0; - for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { - for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face, ++i) { - face_values_per_node(node_id, i_face) = 3 + i * i; - } - } - } - - { - size_t i = 0; + bool is_same = true; + size_t i = 0; for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face, ++i) { - face_values_per_node.itemValues(node_id)[i_face] = 3 + i * i; + is_same &= (face_values_per_node.itemValues(node_id)[i_face] == 3 + i * i); } } + REQUIRE(is_same); } } } @@ -526,69 +651,122 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") } } - SECTION("WeakItemValue") + SECTION("WeakSubItemValuePerItem") { - // const Mesh<Connectivity<2>>& mesh_2d = MeshDataBaseForTests::get().cartesianMesh<2>(); - // const Connectivity<2>& connectivity = mesh_2d.connectivity(); + const Mesh<Connectivity<2>>& mesh_2d = MeshDataBaseForTests::get().cartesianMesh<2>(); + const Connectivity<2>& connectivity = mesh_2d.connectivity(); + + WeakFaceValuePerCell<int> weak_face_value_per_cell{connectivity}; - // WeakFaceValue<int> weak_face_value{connectivity}; + for (size_t i = 0; i < weak_face_value_per_cell.numberOfValues(); ++i) { + weak_face_value_per_cell[i] = i; + } - // weak_face_value.fill(parallel::rank()); + FaceValuePerCell<const int> face_value_per_cell{weak_face_value_per_cell}; - // FaceValue<const int> face_value{weak_face_value}; + REQUIRE(face_value_per_cell.connectivity_ptr() == weak_face_value_per_cell.connectivity_ptr()); - // REQUIRE(face_value.connectivity_ptr() == weak_face_value.connectivity_ptr()); + bool is_same = true; + for (size_t i = 0; i < weak_face_value_per_cell.numberOfValues(); ++i) { + is_same &= (face_value_per_cell[i] == weak_face_value_per_cell[i]); + } + REQUIRE(is_same); } #ifndef NDEBUG SECTION("error") { - SECTION("checking for build ItemValue") + SECTION("checking for build SubItemValuePerItem") { - // CellValue<int> cell_value; - // REQUIRE_THROWS_AS(cell_value[CellId{0}], AssertError); - - // FaceValue<int> face_value; - // REQUIRE_THROWS_AS(face_value[FaceId{0}], AssertError); - - // EdgeValue<int> edge_value; - // REQUIRE_THROWS_AS(edge_value[EdgeId{0}], AssertError); - - // NodeValue<int> node_value; - // REQUIRE_THROWS_AS(node_value[NodeId{0}], AssertError); + CellValuePerNode<int> cell_value_per_node; + REQUIRE_THROWS_AS(cell_value_per_node[0], AssertError); + REQUIRE_THROWS_AS(cell_value_per_node.itemValues(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); + + FaceValuePerCell<int> face_value_per_cell; + REQUIRE_THROWS_AS(face_value_per_cell[0], AssertError); + REQUIRE_THROWS_AS(face_value_per_cell.itemValues(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); + + CellValuePerEdge<int> cell_value_per_edge; + REQUIRE_THROWS_AS(cell_value_per_edge[0], AssertError); + REQUIRE_THROWS_AS(cell_value_per_edge.itemValues(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); + + NodeValuePerFace<int> node_value_per_face; + REQUIRE_THROWS_AS(node_value_per_face[0], AssertError); + REQUIRE_THROWS_AS(node_value_per_face.itemValues(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); } SECTION("checking for bounds violation") { - // const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>(); - // const Connectivity<3>& connectivity = mesh_3d.connectivity(); - - // CellValue<int> cell_value{connectivity}; - // CellId invalid_cell_id = connectivity.numberOfCells(); - // REQUIRE_THROWS_AS(cell_value[invalid_cell_id], AssertError); - - // FaceValue<int> face_value{connectivity}; - // FaceId invalid_face_id = connectivity.numberOfFaces(); - // REQUIRE_THROWS_AS(face_value[invalid_face_id], AssertError); - - // EdgeValue<int> edge_value{connectivity}; - // EdgeId invalid_edge_id = connectivity.numberOfEdges(); - // REQUIRE_THROWS_AS(edge_value[invalid_edge_id], AssertError); + const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>(); + const Connectivity<3>& connectivity = mesh_3d.connectivity(); - // NodeValue<int> node_value{connectivity}; - // NodeId invalid_node_id = connectivity.numberOfNodes(); - // REQUIRE_THROWS_AS(node_value[invalid_node_id], AssertError); - } + 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); + } + if (connectivity.numberOfFaces() > 0) { + FaceId face_id = 0; + const auto& cell_values = cell_value_per_face.itemValues(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.itemValues(face_id)[cell_values.size()] = 2, AssertError); + } - SECTION("set values from invalid array size") - { - // const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>(); - // const Connectivity<3>& connectivity = mesh_3d.connectivity(); + 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); + } + if (connectivity.numberOfNodes() > 0) { + NodeId node_id = 0; + const auto& face_values = face_value_per_node.itemValues(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.itemValues(node_id)[face_values.size()] = 2, AssertError); + } - // CellValue<size_t> cell_value{connectivity}; + 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); + } + if (connectivity.numberOfCells() > 0) { + CellId cell_id = 0; + const auto& edge_values = edge_value_per_cell.itemValues(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.itemValues(cell_id)[edge_values.size()] = 2, AssertError); + } - // Array<size_t> values{3 + cell_value.size()}; - // REQUIRE_THROWS_AS(cell_value = values, AssertError); + 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); + } + if (connectivity.numberOfEdges() > 0) { + EdgeId edge_id = 0; + const auto& node_values = node_value_per_edge.itemValues(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.itemValues(edge_id)[node_values.size()] = 2, AssertError); + } } } #endif // NDEBUG -- GitLab