Increase coverage

Author: tpadioleau

src/ddc/print.hpp

@@ -268,7 +268,7 @@ void print_dim_name(
 template <class... Dims>
 void print_dim_name(std::ostream& os, DiscreteVector<Dims...> const& dd)
 {
-    std::array const names {typeid(Dims).name()...};
+    std::array<char const*, sizeof...(Dims)> const names {typeid(Dims).name()...};
     std::array const std_dd = detail::array(dd);
     print_dim_name(os, names.data(), std_dd.data(), std_dd.size());
 }

tests/discrete_element.cpp

@@ -241,6 +241,14 @@ TEST(DiscreteElementXYZTest, RightExternalBinaryOperatorMinus)
     EXPECT_EQ(ixyz2.uid<DDimZ>(), uid_z);
 }
 
+TEST(DiscreteElement0DTest, StreamOperator)
+{
+    ddc::DiscreteElement<> const i0d;
+    std::stringstream ss;
+    ss << i0d;
+    EXPECT_EQ(ss.str(), "()");
+}
+
 TEST(DiscreteElementXYZTest, StreamOperator)
 {
     ddc::DiscreteElementType const uid_x = 7;

tests/discrete_space.cpp

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <sstream>
 #include <stdexcept>
 
 #include <ddc/ddc.hpp>
@@ -43,3 +44,17 @@ TEST(DiscreteSpace, Initialization)
             static_cast<void const*>(&ddc::discrete_space<DDimX>()),
             static_cast<void const*>(&ddc::host_discrete_space<DDimX>()));
 }
+
+TEST(DiscreteSpace, DisplayDiscretizationStore)
+{
+    ddc::init_discrete_space<DDimX>(DDimX::template init<DDimX>(
+            ddc::Coordinate<DimX>(0),
+            ddc::Coordinate<DimX>(1),
+            ddc::DiscreteVector<DDimX>(2)));
+    std::stringstream ss;
+    ddc::detail::display_discretization_store(ss);
+    EXPECT_EQ(
+            ss.str(),
+            "The host discretization store is initialized:\n - "
+            "N49anonymous_namespace_workaround_discrete_space_cpp5DDimXE\n");
+}

tests/discrete_vector.cpp

@@ -206,6 +206,14 @@ TEST(DiscreteVectorTest, ExternalBinaryOperatorMinus)
     EXPECT_EQ(ddc::get<DDimZ>(result5), dv_z - dv2_z);
 }
 
+TEST(DiscreteVector0DTest, StreamOperator)
+{
+    ddc::DiscreteVector<> const dv0d;
+    std::stringstream ss;
+    ss << dv0d;
+    EXPECT_EQ(ss.str(), "()");
+}
+
 TEST(DiscreteVectorTest, StreamOperator)
 {
     ddc::DiscreteVectorElement const dv_x = 7;

tests/print.cpp

@@ -270,7 +270,28 @@ TEST(Print, CheckOutput3d)
 }
 
 #if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG)
-void TestPrintTestMetadata()
+TEST(Print, CheckMetadata0d)
+{
+    using ElementType = double;
+
+    ddc::DiscreteDomain<> const domain_0d;
+
+    ddc::Chunk chunk("chunk", domain_0d, ddc::DeviceAllocator<ElementType>());
+    ddc::ChunkSpan const chunk_span = chunk.span_view();
+
+    {
+        std::stringstream ss;
+        print_type_info(ss, chunk_span);
+        EXPECT_THAT(
+                ss.str(),
+                testing::MatchesRegex(
+                        "Scalar\n"
+                        "ddc::ChunkSpan<double, ddc::DiscreteDomain<>"
+                        ", Kokkos::layout_.+, Kokkos::.+Space>\n"));
+    }
+}
+
+void TestPrintTestMetadata2d()
 {
     using ElementType = double;
 
@@ -302,8 +323,8 @@ void TestPrintTestMetadata()
     }
 }
 
-TEST(Print, CheckMetadata)
+TEST(Print, CheckMetadata2d)
 {
-    TestPrintTestMetadata();
+    TestPrintTestMetadata2d();
 }
 #endif

tests/splines/CMakeLists.txt

@@ -12,6 +12,7 @@ add_executable(
     bsplines.cpp
     knots_as_interpolation_points.cpp
     splines_linear_problem.cpp
+    spline_boundary_conditions.cpp
     spline_builder.cpp
     spline_traits.cpp
     view.cpp

tests/splines/spline_boundary_conditions.cpp

@@ -0,0 +1,29 @@
+// Copyright (C) The DDC development team, see COPYRIGHT.md file
+//
+// SPDX-License-Identifier: MIT
+
+#include <sstream>
+#include <stdexcept>
+
+#include <ddc/ddc.hpp>
+#include <ddc/kernels/splines.hpp>
+
+#include <gtest/gtest.h>
+
+TEST(SplineBoundaryConditions, StreamOperator)
+{
+    std::stringstream ss;
+    ss << ddc::BoundCond::GREVILLE;
+    EXPECT_EQ("GREVILLE", ss.str());
+
+    ss.str("");
+    ss << ddc::BoundCond::HERMITE;
+    EXPECT_EQ("HERMITE", ss.str());
+
+    ss.str("");
+    ss << ddc::BoundCond::PERIODIC;
+    EXPECT_EQ("PERIODIC", ss.str());
+
+    ss.str("");
+    EXPECT_THROW((ss << static_cast<ddc::BoundCond>(-1)), std::runtime_error);
+}