Properly distinguish flush modi in tests

Author: franzpoeschel

include/openPMD/Series.hpp

@@ -789,6 +789,8 @@ class Series : public Attributable
             "Cannot call this on an instance of Series.");
     }
 
+    [[nodiscard]] bool flushImmediately() const;
+
     // clang-format off
 OPENPMD_private
     // clang-format on

src/Series.cpp

@@ -3549,6 +3549,16 @@ void Series::close()
     m_attri.reset();
 }
 
+bool Series::flushImmediately() const
+{
+    auto ioHandler = IOHandler();
+    if (!ioHandler)
+    {
+        return false;
+    }
+    return ioHandler->m_flush_immediately;
+}
+
 auto Series::currentSnapshot() -> std::optional<std::vector<IterationIndex_t>>
 {
     using vec_t = std::vector<IterationIndex_t>;

test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp

@@ -39,6 +39,11 @@ auto worker(std::string const &ext) -> void
     std::string filename = "../samples/ptl_%T." + ext;
 
     Series series = Series(filename, Access::CREATE_LINEAR, MPI_COMM_WORLD);
+    if (series.flushImmediately())
+    {
+        // Cannot run this test in immediate flush mode
+        return;
+    }
 
     Datatype datatype = determineDatatype<float>();
 

test/ParallelIOTest.cpp

@@ -147,7 +147,7 @@ void write_test_zero_extent(
         Access::CREATE_LINEAR,
         MPI_COMM_WORLD);
 
-    if (!writeAllChunks)
+    if (o.flushImmediately() && !writeAllChunks)
     {
         // immediate flushing makes storeChunk collective, cannot do this
         return;
@@ -917,8 +917,23 @@ void close_iteration_test(std::string const &file_ending)
             REQUIRE(data[i % 4] == chunk.get()[i]);
         }
         // Cannot write/read chunks to/from closed Iterations.
-        // auto read_again = E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4});
-        // REQUIRE_THROWS(read.flush());
+        if (read.flushImmediately())
+        {
+            REQUIRE_THROWS_WITH(
+                E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4}),
+#if openPMD_USE_INVASIVE_TESTS
+                "Cannot write/read chunks to/from closed Iterations."
+#else
+                "Wrong API usage: [Series] Closed iteration (idx=1) must be "
+                "open()ed explicitly before interacting with it again."
+#endif
+            );
+        }
+        else
+        {
+            auto read_again = E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4});
+            // REQUIRE_THROWS(read.flush());
+        }
     }
 
     chunk_assignment::RankMeta compare;

test/SerialIOTest.cpp

@@ -4306,7 +4306,6 @@ enum class FlushDuringStep : std::uint8_t
 
 void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
 {
-    return;
     constexpr size_t size = size_t(1024) * 1024;
 
     auto getsize = []() {
@@ -4351,6 +4350,7 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
     Datatype dtype = determineDatatype<int32_t>();
     {
         Series write("../samples/bp5_flush.bp", Access::CREATE_LINEAR, cfg);
+        bool flushImmediately = write.flushImmediately();
 
         {
             auto component =
@@ -4387,8 +4387,16 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
         if (flushDuringStep == FlushDuringStep::Default_Yes ||
             flushDuringStep == FlushDuringStep::Always)
         {
-            // should still be roughly within 1% of 4Mb
-            REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01);
+            if (flushImmediately)
+            {
+                // should still be roughly within 1% of 8Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            }
+            else
+            {
+                // should still be roughly within 1% of 4Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01);
+            }
         }
         else
         {
@@ -4428,8 +4436,17 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
         }
         else if (flushDuringStep == FlushDuringStep::Default_Yes)
         {
-            // should now be roughly within 1% of 8Mb
-            REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            if (flushImmediately)
+            {
+                // should now be roughly within 1% of 12Mb
+                REQUIRE(
+                    std::abs(1 - double(currentSize) / (12 * size)) <= 0.01);
+            }
+            else
+            {
+                // should now be roughly within 1% of 8Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            }
         }
         else
         {