add SimpleInit utility for gtest, refactor tests to replace EXPECT_DEATH_IF_SUPPORTED with EXPECT_TRUE using DestructorFailureFlag, and update runner initialization methods for consistency

Author: allnes

modules/core/performance/tests/perf_tests.cpp

@@ -296,13 +296,13 @@ TEST(PerfTest, PipelineRunAndTaskRun) {
 }
 
 TEST(PerfTest, PrintPerfStatisticThrowsOnNone) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
-  auto test_func = [&] {
+  {
     auto task_ptr = std::make_shared<DummyTask>();
     ppc::core::Perf<int, int> perf(task_ptr);
     EXPECT_THROW(perf.PrintPerfStatistic("test"), std::runtime_error);
-  };
-  ASSERT_DEATH_IF_SUPPORTED({ test_func(); }, "");
+  }
+  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
+  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(PerfTest, GetStringParamNameTest) {
@@ -312,15 +312,15 @@ TEST(PerfTest, GetStringParamNameTest) {
 }
 
 TEST(TaskTest, Destructor_InvalidPipelineOrderTerminates_PartialPipeline) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
-  auto test_func = [&] {
+  {
     struct BadTask : ppc::core::Task<int, int> {
       bool ValidationImpl() override { return true; }
       bool PreProcessingImpl() override { return true; }
       bool RunImpl() override { return true; }
       bool PostProcessingImpl() override { return true; }
     } task;
     task.Validation();
-  };
-  ASSERT_DEATH_IF_SUPPORTED({ test_func(); }, "ORDER OF FUNCTIONS IS NOT RIGHT");
+  }
+  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
+  ppc::util::DestructorFailureFlag::Unset();
 }

modules/core/runners/include/runners.hpp

@@ -43,4 +43,10 @@ class WorkerTestFailurePrinter : public ::testing::EmptyTestEventListener {
 ///         finalization fails.
 int Init(int argc, char** argv);
 
+/// @brief Initializes the testing environment only for gtest.
+/// @param argc Argument count.
+/// @param argv Argument vector.
+/// @return Exit code from RUN_ALL_TESTS.
+int SimpleInit(int argc, char** argv);
+
 }  // namespace ppc::core

modules/core/runners/src/runners.cpp

@@ -7,6 +7,7 @@
 #include <format>
 #include <iostream>
 #include <memory>
+#include <stdexcept>
 #include <string>
 
 #include "core/util/include/util.hpp"
@@ -82,6 +83,11 @@ int Init(int argc, char** argv) {
   listeners.Append(new ppc::core::UnreadMessagesDetector());
   auto status = RUN_ALL_TESTS();
 
+  if (ppc::util::DestructorFailureFlag::Get()) {
+    throw std::runtime_error(
+        std::format("[  ERROR  ] Destructor failed with code {}", ppc::util::DestructorFailureFlag::Get()));
+  }
+
   const int finalize_res = MPI_Finalize();
   if (finalize_res != MPI_SUCCESS) {
     std::cerr << std::format("[  ERROR  ] MPI_Finalize failed with code {}", finalize_res) << '\n';
@@ -91,4 +97,17 @@ int Init(int argc, char** argv) {
   return status;
 }
 
+int SimpleInit(int argc, char** argv) {
+  // Limit the number of threads in TBB
+  tbb::global_control control(tbb::global_control::max_allowed_parallelism, ppc::util::GetNumThreads());
+
+  testing::InitGoogleTest(&argc, argv);
+  auto status = RUN_ALL_TESTS();
+  if (ppc::util::DestructorFailureFlag::Get()) {
+    throw std::runtime_error(
+        std::format("[  ERROR  ] Destructor failed with code {}", ppc::util::DestructorFailureFlag::Get()));
+  }
+  return status;
+}
+
 }  // namespace ppc::core

modules/core/task/include/task.hpp

@@ -194,8 +194,7 @@ class Task {
   /// @note Terminates the program if the pipeline order is incorrect or incomplete.
   virtual ~Task() {
     if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException) {
-      std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT" << '\n';
-      std::terminate();
+      ppc::util::DestructorFailureFlag::Set();
     }
 #if _OPENMP >= 201811
     omp_pause_resource_all(omp_pause_soft);

modules/core/task/tests/task_tests.cpp

@@ -10,6 +10,7 @@
 #include <thread>
 #include <vector>
 
+#include "core/runners/include/runners.hpp"
 #include "core/task/include/task.hpp"
 #include "core/task/tests/test_task.hpp"
 
@@ -146,8 +147,7 @@ TEST(TaskTest, GetStringTaskType_ThrowsIfKeyMissing) {
 }
 
 TEST(TaskTest, TaskDestructor_ThrowsIfStageIncomplete) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
-  auto destroy_func = [] {
+  {
     std::vector<int32_t> in(20, 1);
     struct LocalTask : ppc::core::Task<std::vector<int32_t>, int32_t> {
       explicit LocalTask(const std::vector<int32_t>& in) { this->GetInput() = in; }
@@ -157,13 +157,13 @@ TEST(TaskTest, TaskDestructor_ThrowsIfStageIncomplete) {
       bool PostProcessingImpl() override { return true; }
     } task(in);
     task.Validation();
-  };
-  EXPECT_DEATH_IF_SUPPORTED({ destroy_func(); }, ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+  }
+  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
+  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, TaskDestructor_ThrowsIfEmpty) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
-  auto destroy_func = [] {
+  {
     std::vector<int32_t> in(20, 1);
     struct LocalTask : ppc::core::Task<std::vector<int32_t>, int32_t> {
       explicit LocalTask(const std::vector<int32_t>& in) { this->GetInput() = in; }
@@ -172,8 +172,9 @@ TEST(TaskTest, TaskDestructor_ThrowsIfEmpty) {
       bool RunImpl() override { return true; }
       bool PostProcessingImpl() override { return true; }
     } task(in);
-  };
-  EXPECT_DEATH_IF_SUPPORTED({ destroy_func(); }, ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+  }
+  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
+  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, InternalTimeTest_ThrowsIfTimeoutExceeded) {
@@ -229,7 +230,4 @@ TEST(TaskTest, PostProcessingThrowsIfCalledBeforeRun) {
   EXPECT_THROW(task->PostProcessing(), std::runtime_error);
 }
 
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
+int main(int argc, char** argv) { return ppc::core::SimpleInit(argc, argv); }

modules/core/util/include/util.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
@@ -29,6 +30,24 @@ using NlohmannJsonTypeError = nlohmann::json::type_error;
 
 namespace ppc::util {
 
+/// @brief Utility class for tracking destructor failure across tests.
+/// @details Provides thread-safe methods to set, unset, and check the failure flag.
+class DestructorFailureFlag {
+ public:
+  /// @brief Marks that a destructor failure has occurred.
+  static void Set() { failure_flag.store(true); }
+
+  /// @brief Clears the destructor failure flag.
+  static void Unset() { failure_flag.store(false); }
+
+  /// @brief Checks if a destructor failure was recorded.
+  /// @return True if failure occurred, false otherwise.
+  static bool Get() { return failure_flag.load(); }
+
+ private:
+  inline static std::atomic<bool> failure_flag{false};
+};
+
 enum GTestParamIndex : uint8_t { kTaskGetter, kNameTest, kTestParams };
 
 std::string GetAbsoluteTaskPath(const std::string& id_path, const std::string& relative_path);

tasks/common/runners/functional.cpp

@@ -8,10 +8,5 @@ int main(int argc, char** argv) {
   if (ppc::util::IsUnderMpirun()) {
     return ppc::core::Init(argc, argv);
   }
-
-  // Limit the number of threads in TBB
-  tbb::global_control control(tbb::global_control::max_allowed_parallelism, ppc::util::GetNumThreads());
-
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
+  return ppc::core::SimpleInit(argc, argv);
 }