test_ItemValue.cpp

#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>

#include <MeshDataBaseForTests.hpp>
#include <mesh/Connectivity.hpp>
#include <mesh/ItemValue.hpp>
#include <mesh/Mesh.hpp>
#include <utils/Messenger.hpp>

// clazy:excludeall=non-pod-global-static

TEST_CASE("ItemValue", "[mesh]")
{
  SECTION("default constructors")
  {
    REQUIRE_NOTHROW(NodeValue<int>{});
    REQUIRE_NOTHROW(EdgeValue<int>{});
    REQUIRE_NOTHROW(FaceValue<int>{});
    REQUIRE_NOTHROW(CellValue<int>{});

    REQUIRE(not NodeValue<int>{}.isBuilt());
    REQUIRE(not EdgeValue<int>{}.isBuilt());
    REQUIRE(not FaceValue<int>{}.isBuilt());
    REQUIRE(not CellValue<int>{}.isBuilt());
  }

  SECTION("1D")
  {
    std::array mesh_list = MeshDataBaseForTests::get().all1DMeshes();

    for (auto named_mesh : mesh_list) {
      SECTION(named_mesh.name())
      {
        auto mesh_1d = named_mesh.mesh();

        const Connectivity<1>& connectivity = mesh_1d->connectivity();

        REQUIRE_NOTHROW(NodeValue<int>{connectivity});
        REQUIRE_NOTHROW(EdgeValue<int>{connectivity});
        REQUIRE_NOTHROW(FaceValue<int>{connectivity});
        REQUIRE_NOTHROW(CellValue<int>{connectivity});

        REQUIRE(NodeValue<int>{connectivity}.isBuilt());
        REQUIRE(EdgeValue<int>{connectivity}.isBuilt());
        REQUIRE(FaceValue<int>{connectivity}.isBuilt());
        REQUIRE(CellValue<int>{connectivity}.isBuilt());

        NodeValue<int> node_value{connectivity};
        EdgeValue<int> edge_value{connectivity};
        FaceValue<int> face_value{connectivity};
        CellValue<int> cell_value{connectivity};

        REQUIRE(edge_value.numberOfItems() == node_value.numberOfItems());
        REQUIRE(face_value.numberOfItems() == node_value.numberOfItems());
        REQUIRE(cell_value.numberOfItems() + 1 == node_value.numberOfItems());
      }
    }
  }

  SECTION("2D")
  {
    std::array mesh_list = MeshDataBaseForTests::get().all2DMeshes();

    for (auto named_mesh : mesh_list) {
      SECTION(named_mesh.name())
      {
        auto mesh_2d = named_mesh.mesh();

        const Connectivity<2>& connectivity = mesh_2d->connectivity();