BUG: Fix OOC Review Findings

CMakeLists.txt

@@ -375,6 +375,7 @@ set(SIMPLNX_HDRS
   ${SIMPLNX_SOURCE_DIR}/Common/Constants.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/DataTypeUtilities.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/DataVector.hpp
+  ${SIMPLNX_SOURCE_DIR}/Common/BoundedRead.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/Extent.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/EulerAngle.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/Filesystem.hpp
@@ -868,6 +869,7 @@ set(SIMPLNX_SRCS
   ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/ChunkShapePolicy.cpp
   ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/DeflateEligibility.cpp
   ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/ParallelChunkCodec.cpp
+  ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/BoundedChunkRead.cpp
 
   ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/IO/DatasetIO.cpp
   ${SIMPLNX_SOURCE_DIR}/Utilities/Parsing/HDF5/IO/FileIO.cpp
@@ -1021,6 +1023,30 @@ foreach(plugin ${SIMPLNX_PLUGIN_LIST})
   simplnx_add_plugin(PLUGIN_NAME ${plugin})
 endforeach()
 
+# Register the completion acceptance cases after their real fixture/writer plugins exist.
+if(BUILD_TESTING AND SIMPLNX_BUILD_TESTS AND SIMPLNX_PLUGIN_ENABLE_TestOne AND SIMPLNX_ENABLE_SimplnxCore AND SIMPLNX_PLUGIN_ENABLE_SimplnxCore)
+  foreach(_completion_target IN ITEMS nxrunner TestOne SimplnxCore)
+    if(NOT TARGET ${_completion_target})
+      message(FATAL_ERROR "Completion CLI tests require target '${_completion_target}' after plugin registration")
+    endif()
+  endforeach()
+  add_dependencies(nxrunner TestOne SimplnxCore)
+  foreach(_completion_mode IN ITEMS unarmed flush execute_and_flush allocation snapshot root_snapshot snapshot_allocation)
+    add_test(NAME "nxrunner_pipeline_flush_${_completion_mode}"
+      COMMAND ${CMAKE_COMMAND}
+        "-DNXRUNNER_EXECUTABLE=$<TARGET_FILE:nxrunner>"
+        "-DTEST_MODE=${_completion_mode}"
+        "-DSCRATCH_ROOT=${simplnx_BINARY_DIR}/CTestPipelineFlush/${_completion_mode}/$<CONFIG>"
+        -P "${simplnx_SOURCE_DIR}/src/nxrunner/test/PipelineFlushReachesUserTest.cmake"
+    )
+    set_tests_properties("nxrunner_pipeline_flush_${_completion_mode}" PROPERTIES
+      RUN_SERIAL TRUE
+      TIMEOUT 120
+      WORKING_DIRECTORY $<TARGET_FILE_DIR:nxrunner>
+    )
+  endforeach()
+endif()
+
 # Benchmarking utility
 if(SIMPLNX_ENABLE_BENCHMARK_UTILITY)
   add_subdirectory(utilities/benchmark)

src/Plugins/ImageProcessing/benchmark/BenchmarkPreferenceSnapshot.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "simplnx/Core/Preferences.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <stdexcept>
+
+namespace ip_bench
+{
+/**
+ * @brief Restores exact explicit storage preferences after a benchmark scope.
+ *
+ * The benchmark tools do not link UnitTestCommon. This guard changes only the
+ * in-memory Preferences object and does not save a preferences file.
+ */
+class BenchmarkPreferenceSnapshot
+{
+public:
+  /**
+   * @brief Validates and applies a temporary storage mode and threshold.
+   * @param preferences Preference object to change and restore.
+   * @param mode Temporary storage mode.
+   * @param temporaryThreshold Signed temporary threshold in bytes.
+   */
+  BenchmarkPreferenceSnapshot(nx::core::Preferences& preferences, nx::core::DataStorageMode mode, nx::core::int64 temporaryThreshold = 0)
+  : m_Preferences(preferences)
+  , m_HadMode(preferences.contains(nx::core::Preferences::k_DataStorageMode_Key))
+  , m_OriginalMode(preferences.value(nx::core::Preferences::k_DataStorageMode_Key))
+  , m_HadThreshold(preferences.contains(nx::core::Preferences::k_LargeDataSize_Key))
+  , m_OriginalThreshold(preferences.value(nx::core::Preferences::k_LargeDataSize_Key))
+  {
+    const nlohmann::json proposed(temporaryThreshold);
+    const auto validation = nx::core::Preferences::ValidateOocSizeValue(nx::core::Preferences::k_LargeDataSize_Key, proposed);
+    if(validation.invalid())
+    {
+      throw std::invalid_argument(validation.errors().front().message);
+    }
+    m_Preferences.setDataStorageMode(mode);
+    m_Preferences.setValue(nx::core::Preferences::k_LargeDataSize_Key, proposed);
+  }
+
+  ~BenchmarkPreferenceSnapshot()
+  {
+    if(m_HadThreshold)
+    {
+      m_Preferences.setValue(nx::core::Preferences::k_LargeDataSize_Key, m_OriginalThreshold);
+    }
+    else
+    {
+      m_Preferences.removeValue(nx::core::Preferences::k_LargeDataSize_Key);
+    }
+    if(m_HadMode)
+    {
+      m_Preferences.setValue(nx::core::Preferences::k_DataStorageMode_Key, m_OriginalMode);
+    }
+    else
+    {
+      m_Preferences.removeValue(nx::core::Preferences::k_DataStorageMode_Key);
+    }
+  }
+
+  BenchmarkPreferenceSnapshot(const BenchmarkPreferenceSnapshot&) = delete;
+  BenchmarkPreferenceSnapshot(BenchmarkPreferenceSnapshot&&) = delete;
+  BenchmarkPreferenceSnapshot& operator=(const BenchmarkPreferenceSnapshot&) = delete;
+  BenchmarkPreferenceSnapshot& operator=(BenchmarkPreferenceSnapshot&&) = delete;
+
+private:
+  nx::core::Preferences& m_Preferences;
+  bool m_HadMode = false;
+  nlohmann::json m_OriginalMode;
+  bool m_HadThreshold = false;
+  nlohmann::json m_OriginalThreshold;
+};
+} // namespace ip_bench

src/Plugins/ImageProcessing/benchmark/BenchmarkPreferenceSnapshotTest.cpp

@@ -0,0 +1,67 @@
+#define CATCH_CONFIG_MAIN
+
+#include "BenchmarkPreferenceSnapshot.hpp"
+
+#include <catch2/catch.hpp>
+
+#include <limits>
+#include <stdexcept>
+
+using namespace nx::core;
+
+TEST_CASE("Benchmark preference snapshot restores exact JSON and key presence", "[Core][Preferences][OocThreshold]")
+{
+  for(const auto& original : {nlohmann::json(int64{0}), nlohmann::json(int64{37}), nlohmann::json(uint64{0}), nlohmann::json(uint64{37}), nlohmann::json(std::numeric_limits<uint64>::max())})
+  {
+    DYNAMIC_SECTION(original.dump() << " type=" << static_cast<int>(original.type()))
+    {
+      Preferences preferences;
+      preferences.setValue(Preferences::k_LargeDataSize_Key, original);
+      preferences.setDataStorageMode(DataStorageMode::Adaptive);
+      const auto mode = preferences.value(Preferences::k_DataStorageMode_Key);
+      {
+        ip_bench::BenchmarkPreferenceSnapshot snapshot(preferences, DataStorageMode::ForceInCore, 19);
+        CHECK(preferences.valueAs<uint64>(Preferences::k_LargeDataSize_Key) == 19);
+        CHECK(preferences.dataStorageMode() == DataStorageMode::ForceInCore);
+      }
+      const auto restored = preferences.value(Preferences::k_LargeDataSize_Key);
+      REQUIRE(preferences.contains(Preferences::k_LargeDataSize_Key));
+      REQUIRE(restored.type() == original.type());
+      CHECK(restored.get<uint64>() == original.get<uint64>());
+      CHECK(preferences.value(Preferences::k_DataStorageMode_Key) == mode);
+      CHECK(preferences.value(Preferences::k_DataStorageMode_Key).type() == mode.type());
+      CHECK(preferences.contains(Preferences::k_DataStorageMode_Key));
+    }
+  }
+
+  Preferences absent;
+  absent.removeValue(Preferences::k_LargeDataSize_Key);
+  absent.removeValue(Preferences::k_DataStorageMode_Key);
+  {
+    ip_bench::BenchmarkPreferenceSnapshot snapshot(absent, DataStorageMode::ForceOutOfCore);
+    CHECK(absent.valueAs<uint64>(Preferences::k_LargeDataSize_Key) == 0);
+  }
+  CHECK_FALSE(absent.contains(Preferences::k_LargeDataSize_Key));
+  CHECK_FALSE(absent.contains(Preferences::k_DataStorageMode_Key));
+}
+
+TEST_CASE("Benchmark preference snapshot rejects a negative threshold before mode mutation", "[Core][Preferences][OocThreshold]")
+{
+  Preferences preferences;
+  preferences.setValue(Preferences::k_LargeDataSize_Key, std::numeric_limits<uint64>::max());
+  preferences.setDataStorageMode(DataStorageMode::Adaptive);
+  const auto originalThreshold = preferences.value(Preferences::k_LargeDataSize_Key);
+  const auto originalMode = preferences.value(Preferences::k_DataStorageMode_Key);
+  REQUIRE_THROWS_AS(ip_bench::BenchmarkPreferenceSnapshot(preferences, DataStorageMode::ForceOutOfCore, -1), std::invalid_argument);
+  CHECK(preferences.value(Preferences::k_LargeDataSize_Key) == originalThreshold);
+  CHECK(preferences.value(Preferences::k_LargeDataSize_Key).type() == originalThreshold.type());
+  CHECK(preferences.value(Preferences::k_DataStorageMode_Key) == originalMode);
+  CHECK(preferences.value(Preferences::k_DataStorageMode_Key).type() == originalMode.type());
+  CHECK(preferences.contains(Preferences::k_LargeDataSize_Key));
+  CHECK(preferences.contains(Preferences::k_DataStorageMode_Key));
+
+  Preferences absent;
+  REQUIRE_THROWS_AS(ip_bench::BenchmarkPreferenceSnapshot(absent, DataStorageMode::ForceOutOfCore, -1), std::invalid_argument);
+  CHECK_FALSE(absent.contains(Preferences::k_LargeDataSize_Key));
+  CHECK_FALSE(absent.contains(Preferences::k_DataStorageMode_Key));
+}

src/Plugins/ImageProcessing/benchmark/BenchmarkRunner.cpp

@@ -1,4 +1,5 @@
 #include "BenchmarkRunner.hpp"
+#include "BenchmarkPreferenceSnapshot.hpp"
 
 #include "BenchmarkTiling.hpp"
 
@@ -38,37 +39,6 @@ std::string FirstErrorMessage(const std::vector<Error>& errors)
   return errors.empty() ? "(no message)" : errors.front().message;
 }
 
-// RAII sentinel that mirrors UnitTest::PreferencesSentinel (save mode + large_data_size, apply, restore on
-// destruction). Re-implemented locally because this standalone tool deliberately does NOT link the UnitTestCommon
-// .cpp that defines PreferencesSentinel's ctor/dtor (see benchmark/CMakeLists.txt). This one restores in-memory only
-// -- it never writes the preferences file to disk.
-class BenchPreferencesSentinel
-{
-public:
-  BenchPreferencesSentinel(DataStorageMode mode, int64 largeDataSize)
-  {
-    auto* prefs = Application::Instance()->getPreferences();
-    m_OriginalMode = prefs->dataStorageMode();
-    m_OriginalSize = prefs->valueAs<int64>(Preferences::k_LargeDataSize_Key);
-    prefs->setDataStorageMode(mode);
-    prefs->setValue(Preferences::k_LargeDataSize_Key, largeDataSize);
-  }
-  ~BenchPreferencesSentinel()
-  {
-    auto* prefs = Application::Instance()->getPreferences();
-    prefs->setDataStorageMode(m_OriginalMode);
-    prefs->setValue(Preferences::k_LargeDataSize_Key, m_OriginalSize);
-  }
-  BenchPreferencesSentinel(const BenchPreferencesSentinel&) = delete;
-  BenchPreferencesSentinel(BenchPreferencesSentinel&&) = delete;
-  BenchPreferencesSentinel& operator=(const BenchPreferencesSentinel&) = delete;
-  BenchPreferencesSentinel& operator=(BenchPreferencesSentinel&&) = delete;
-
-private:
-  DataStorageMode m_OriginalMode;
-  int64 m_OriginalSize;
-};
-
 // Removes every DataObject NOT present in @p baseline (the set of IDs snapshotted right after the tiled input was
 // built). Handles both in-place-output filters (an array under the shared cell AM) and new-geometry-output filters
 // like MaximumProjection (a whole new ImageGeom). removeData recurses into children and is a no-op for IDs already
@@ -397,7 +367,7 @@ BenchmarkRow RunFilterBenchmark(const BenchmarkFilterSpec& spec, const SweepOpti
   DataStructure dsInCore;
   DataPath inputPath;
   {
-    const BenchPreferencesSentinel sentinel(DataStorageMode::ForceInCore, 0);
+    const ip_bench::BenchmarkPreferenceSnapshot sentinel(*Application::Instance()->getPreferences(), DataStorageMode::ForceInCore);
     Result<DataPath> r = PrepareBenchmarkInput(dsInCore, spec, geom, cellAmName, inArrayName, opts.targetVoxels, opts.minZSlices, opts.force2D, DataStorageMode::ForceInCore);
     if(r.invalid())
     {
@@ -418,7 +388,7 @@ BenchmarkRow RunFilterBenchmark(const BenchmarkFilterSpec& spec, const SweepOpti
   // --- new-in-core ---
   if(!opts.oocOnly)
   {
-    const BenchPreferencesSentinel sentinel(DataStorageMode::ForceInCore, 0);
+    const ip_bench::BenchmarkPreferenceSnapshot sentinel(*Application::Instance()->getPreferences(), DataStorageMode::ForceInCore);
     std::string note;
     row.newIncoreMs = RunConfig(filterList, spec.newFilterUuid, dsInCore, baseInCore, spec, geom, inputPath, outName, opts.warmup, opts.repeats, opts.projectionAxis, note);
     if(!note.empty())
@@ -435,7 +405,7 @@ BenchmarkRow RunFilterBenchmark(const BenchmarkFilterSpec& spec, const SweepOpti
     DataPath oocInput;
     bool built = false;
     {
-      const BenchPreferencesSentinel sentinel(DataStorageMode::ForceOutOfCore, opts.oocThreshold);
+      const ip_bench::BenchmarkPreferenceSnapshot sentinel(*Application::Instance()->getPreferences(), DataStorageMode::ForceOutOfCore, opts.oocThreshold);
       Result<DataPath> r = PrepareBenchmarkInput(dsOoc, spec, geom, cellAmName, inArrayName, opts.targetVoxels, opts.minZSlices, opts.force2D, DataStorageMode::ForceOutOfCore);
       if(r.invalid())
       {
@@ -450,7 +420,7 @@ BenchmarkRow RunFilterBenchmark(const BenchmarkFilterSpec& spec, const SweepOpti
     if(built)
     {
       const std::unordered_set<DataObject::IdType> baseOoc = SnapshotIds(dsOoc);
-      const BenchPreferencesSentinel sentinel(DataStorageMode::ForceOutOfCore, opts.oocThreshold);
+      const ip_bench::BenchmarkPreferenceSnapshot sentinel(*Application::Instance()->getPreferences(), DataStorageMode::ForceOutOfCore, opts.oocThreshold);
       std::string note;
       row.newOocMs = RunConfig(filterList, spec.newFilterUuid, dsOoc, baseOoc, spec, geom, oocInput, outName, opts.warmup, opts.repeats, opts.projectionAxis, note);
       if(!note.empty())

src/Plugins/ImageProcessing/benchmark/WriteImageBenchmark.cpp

@@ -1,3 +1,4 @@
+#include "BenchmarkPreferenceSnapshot.hpp"
 #include "ImageProcessing/Filters/WriteImageFilter.hpp"
 
 #include "simplnx/Common/Result.hpp"
@@ -29,6 +30,7 @@
 #include <fstream>
 #include <memory>
 #include <optional>
+#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <system_error>
@@ -92,35 +94,6 @@ struct TimingRow
   OocCounters counterDelta;
 };
 
-class PreferencesSentinel
-{
-public:
-  explicit PreferencesSentinel(DataStorageMode storageMode)
-  : m_Preferences(Application::Instance()->getPreferences())
-  , m_OriginalMode(m_Preferences->dataStorageMode())
-  , m_OriginalLargeDataSize(m_Preferences->valueAs<int64>(Preferences::k_LargeDataSize_Key))
-  {
-    m_Preferences->setDataStorageMode(storageMode);
-    m_Preferences->setValue(Preferences::k_LargeDataSize_Key, int64{0});
-  }
-
-  ~PreferencesSentinel()
-  {
-    m_Preferences->setDataStorageMode(m_OriginalMode);
-    m_Preferences->setValue(Preferences::k_LargeDataSize_Key, m_OriginalLargeDataSize);
-  }
-
-  PreferencesSentinel(const PreferencesSentinel&) = delete;
-  PreferencesSentinel(PreferencesSentinel&&) = delete;
-  PreferencesSentinel& operator=(const PreferencesSentinel&) = delete;
-  PreferencesSentinel& operator=(PreferencesSentinel&&) = delete;
-
-private:
-  Preferences* m_Preferences = nullptr;
-  DataStorageMode m_OriginalMode = DataStorageMode::Adaptive;
-  int64 m_OriginalLargeDataSize = 0;
-};
-
 std::string FirstError(const Result<>& result)
 {
   return result.errors().empty() ? "operation failed without an error message" : result.errors().front().message;
@@ -275,7 +248,7 @@ Result<> BuildInput(DataStructure& dataStructure, DataStorageMode storageMode)
 
   std::shared_ptr<AbstractDataStore<T>> store;
   {
-    PreferencesSentinel preferences(storageMode);
+    ip_bench::BenchmarkPreferenceSnapshot preferences(*Application::Instance()->getPreferences(), storageMode);
     store = DataStoreUtilities::CreateDataStore<T>(dataStructure, k_InputArrayPath, {k_DimZ, k_DimY, k_DimX}, {1});
   }
   if(store == nullptr)

src/Plugins/ImageProcessing/test/CMakeLists.txt

@@ -156,3 +156,17 @@ foreach(example_name IN LISTS ${PLUGIN_NAME}_EXAMPLE_PIPELINE_NAMES)
 endforeach()
 
 create_pipeline_tests(PLUGIN_NAME ${PLUGIN_NAME} PIPELINE_LIST ${PREBUILT_PIPELINE_NAMES})
+
+# VerifyExamplePipelineCitations.py resolves every citation over the network (doi.org and publisher sites),
+# so it depends on external services and on each agent's certificate store. It is not registered with CTest;
+# run it manually when pipeline citations change.
+
+target_sources(${PLUGIN_NAME}UnitTest PRIVATE "${simplnx_SOURCE_DIR}/test/ProfileIsolationContract.cpp")
+
+add_test(NAME "${PLUGIN_NAME}_test_profile_isolation"
+  COMMAND ${CMAKE_COMMAND}
+    "-DPROFILE_TEST_EXECUTABLE=$<TARGET_FILE:${PLUGIN_NAME}UnitTest>"
+    "-DPROFILE_TEST_ROOT=${CMAKE_CURRENT_BINARY_DIR}/ProfileIsolation"
+    -DPROFILE_RUNNER_ONLY=TRUE
+    -P "${simplnx_SOURCE_DIR}/test/VerifyTestProfileLifecycle.cmake")
+set_tests_properties("${PLUGIN_NAME}_test_profile_isolation" PROPERTIES RUN_SERIAL TRUE TIMEOUT 60)

src/Plugins/ImageProcessing/test/ImageProcessing_test_main.cpp

@@ -1,4 +1,11 @@
 // Catch2 recommends placing these lines by themselves in a translation unit
 // which will help reduce unnecessary recompilations of the expensive Catch main
-#define CATCH_CONFIG_MAIN
+#define CATCH_CONFIG_RUNNER
 #include <catch2/catch.hpp>
+
+#include "simplnx/UnitTest/OwnedCatchRunner.hpp"
+
+int main(int argc, char* argv[])
+{
+  return nx::core::UnitTest::RunOwnedCatchSession(argc, argv);
+}