Add tests for OStream checkpointing

src/utils/checkpointing/ReadOStream.cpp

@@ -25,9 +25,11 @@ readOStream(const std::string& symbol_name, const HighFive::Group& symbol_table_
     p_ostream = std::make_shared<OFStream>(filename, true);
     break;
   }
+    // LCOV_EXCL_START
   case OStream::Type::std_ostream: {
     throw NotImplementedError("std::ostream resume");
   }
+    // LCOV_EXCL_STOP
   }
 
   return {std::make_shared<DataHandler<const OStream>>(p_ostream)};

tests/CMakeLists.txt

@@ -161,6 +161,7 @@ set(checkpointing_TESTS)
 if(PUGS_HAS_HDF5)
   list(APPEND checkpointing_TESTS
     test_checkpointing_HFTypes.cpp
+    test_checkpointing_OStream.cpp
     test_checkpointing_IBoundaryDescriptor.cpp
     test_checkpointing_IBoundaryConditionDescriptor.cpp
     test_checkpointing_IQuadratureDescriptor.cpp

tests/test_checkpointing_OStream.cpp

+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_all.hpp>
+
+#include <utils/Messenger.hpp>
+
+#include <language/utils/DataHandler.hpp>
+#include <language/utils/EmbeddedData.hpp>
+#include <language/utils/OFStream.hpp>
+#include <utils/checkpointing/ReadOStream.hpp>
+#include <utils/checkpointing/WriteOStream.hpp>
+
+#include <filesystem>
+
+// clazy:excludeall=non-pod-global-static
+
+TEST_CASE("checkpointing_OStream", "[utils/checkpointing]")
+{
+  std::string tmp_dirname;
+  {
+    {
+      if (parallel::rank() == 0) {
+        tmp_dirname = [&]() -> std::string {
+          std::string temp_filename = std::filesystem::temp_directory_path() / "pugs_checkpointing_XXXXXX";
+          return std::string{mkdtemp(&temp_filename[0])};
+        }();
+      }
+      parallel::broadcast(tmp_dirname, 0);
+    }
+    std::filesystem::path path = tmp_dirname;
+    const std::string filename = path / "checkpoint.h5";
+
+    HighFive::FileAccessProps fapl;
+    fapl.add(HighFive::MPIOFileAccess{MPI_COMM_WORLD, MPI_INFO_NULL});
+    fapl.add(HighFive::MPIOCollectiveMetadata{});
+    HighFive::File file = HighFive::File(filename, HighFive::File::Truncate, fapl);
+
+    SECTION("OStream")
+    {
+      HighFive::Group symbol_table_group = file.createGroup("symbol_table");
+      HighFive::Group useless_group;
+
+      auto p_ofstream = std::make_shared<OFStream>("output_name");
+      checkpointing::writeOStream("ofstream", EmbeddedData{std::make_shared<DataHandler<const OStream>>(p_ofstream)},
+                                  file, useless_group, symbol_table_group);
+
+      auto p_ostream = std::make_shared<OStream>(std::cout);
+      REQUIRE_THROWS_WITH(checkpointing::writeOStream("ostream",
+                                                      EmbeddedData{
+                                                        std::make_shared<DataHandler<const OStream>>(p_ostream)},
+                                                      file, useless_group, symbol_table_group),
+                          "not implemented yet: std::ostream checkpoint");
+
+      file.flush();
+
+      EmbeddedData read_ofstream = checkpointing::readOStream("ofstream", symbol_table_group);
+
+      auto get_value = [](const EmbeddedData& embedded_data) -> const OStream& {
+        return *dynamic_cast<const DataHandler<const OStream>&>(embedded_data.get()).data_ptr();
+      };
+
+      REQUIRE_NOTHROW(get_value(read_ofstream));
+
+      REQUIRE_NOTHROW(dynamic_cast<const OFStream&>(get_value(read_ofstream)));
+
+      REQUIRE(get_value(read_ofstream).type() == OStream::Type::std_ofstream);
+      REQUIRE(dynamic_cast<const OFStream&>(get_value(read_ofstream)).filename() == "output_name");
+    }
+  }
+
+  parallel::barrier();
+  if (parallel::rank() == 0) {
+    std::filesystem::remove_all(std::filesystem::path{tmp_dirname});
+  }
+}