Skip to content
Snippets Groups Projects
Commit 11650a65 authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Add new constructor for SubItemValuePerItem using an Array of values 

Also make some clean-up and update tests and add a bunch of missing
qualifiers to functions
parent 2056ed42
Branches
Tags
1 merge request!133Simplify access functions to the number of items
Show whitespace changes
Inline Side-by-side
src/mesh/SubItemValuePerItem.hpp
+ 30
− 25
View file @ 11650a65
......@@ -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;
};
......
tests/test_SubItemValuePerItem.cpp
+ 150
− 60
View file @ 11650a65
......@@ -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");
}
}
}
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment