refactor task framework: rename and extend lifecycle handling for better test coverage and clarity

Author: allnes

.github/workflows/static-analysis-pr.yml

@@ -75,7 +75,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
-      - name: Search for linter suppression markers
+      - name: Search for forbidden patterns in student tasks
         run: |
           export BASE_REF=${{ github.event.pull_request.base.ref }}
           export CHANGED_FILES="$(git diff --name-only origin/$BASE_REF HEAD | grep '^tasks/')"
@@ -92,5 +92,9 @@ jobs:
               echo "::error::Found 'IWYU pragma' in $file."
               exit 1
             fi
+            if grep -n "ExpectIncompleteLifecycle" "$file"; then
+              echo "::error::Found 'ExpectIncompleteLifecycle' in $file. This function is for internal testing only and should not be used in student tasks."
+              exit 1
+            fi
           done
-          echo "No linter suppression markers found in changed files."
+          echo "No forbidden patterns found in changed files."

modules/performance/tests/perf_tests.cpp

@@ -282,7 +282,7 @@ TEST(TaskTest, Destructor_WithWrongOrder_TerminatesGracefully) {
   {
     DummyTask task;
     EXPECT_THROW(task.Run(), std::runtime_error);
-    // This task doesn't cause destructor failure - just execution order error
+    // This task doesn't cause destructor failure - just an execution order error
   }
 
   // Create a new task to complete the lifecycle properly
@@ -356,11 +356,10 @@ TEST(PerfTest, PipelineRunAndTaskRun_WithValidTask_ExecutesSuccessfully) {
 TEST(PerfTest, PrintPerfStatistic_WithNoneType_ThrowsException) {
   {
     auto task_ptr = std::make_shared<DummyTask>();
+    task_ptr->ExpectIncompleteLifecycle(); // Task not executed in a performance test
     Perf<int, int> perf(task_ptr);
     EXPECT_THROW(perf.PrintPerfStatistic("test"), std::runtime_error);
   }
-  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(PerfTest, GetStringParamName_WithValidParameters_ReturnsCorrectString) {
@@ -617,10 +616,9 @@ TEST(TaskTest, Destructor_WithInvalidPipelineOrderAndPartialExecution_Terminates
       bool RunImpl() override { return true; }
       bool PostProcessingImpl() override { return true; }
     } task;
+    task.ExpectIncompleteLifecycle(); // Task has incomplete pipeline execution
     task.Validation();
   }
-  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 }  // namespace

modules/runners/src/runners.cpp

@@ -60,17 +60,6 @@ void WorkerTestFailurePrinter::PrintProcessRank() {
   std::cerr << std::format(" [  PROCESS {}  ] ", rank);
 }
 
-namespace {
-int RunAllTests() {
-  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
-
 int Init(int argc, char** argv) {
   const int init_res = MPI_Init(&argc, &argv);
   if (init_res != MPI_SUCCESS) {
@@ -79,21 +68,25 @@ int Init(int argc, char** argv) {
     return init_res;
   }
 
-  // Limit the number of threads in TBB
-  tbb::global_control control(tbb::global_control::max_allowed_parallelism, ppc::util::GetNumThreads());
+  auto status = 0;
+  {
+    // Limit the number of threads in TBB
+    tbb::global_control control(tbb::global_control::max_allowed_parallelism, ppc::util::GetNumThreads());
 
-  ::testing::InitGoogleTest(&argc, argv);
+    ::testing::InitGoogleTest(&argc, argv);
 
-  auto& listeners = ::testing::UnitTest::GetInstance()->listeners();
-  int rank = -1;
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  if (rank != 0 && (argc < 2 || argv[1] != std::string("--print-workers"))) {
-    auto* listener = listeners.Release(listeners.default_result_printer());
-    listeners.Append(new WorkerTestFailurePrinter(std::shared_ptr<::testing::TestEventListener>(listener)));
-  }
-  listeners.Append(new UnreadMessagesDetector());
+    auto& listeners = ::testing::UnitTest::GetInstance()->listeners();
+    int rank = -1;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    if (rank != 0 && (argc < 2 || argv[1] != std::string("--print-workers"))) {
+      auto* listener = listeners.Release(listeners.default_result_printer());
+      listeners.Append(new WorkerTestFailurePrinter(std::shared_ptr<::testing::TestEventListener>(listener)));
+    }
+    listeners.Append(new UnreadMessagesDetector());
+
+    status = RUN_ALL_TESTS();
+  } // TBB control object destroyed here
 
-  auto status = RunAllTests();
 
   const int finalize_res = MPI_Finalize();
   if (finalize_res != MPI_SUCCESS) {
@@ -105,11 +98,16 @@ int Init(int argc, char** argv) {
 }
 
 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());
+  auto status = 0;
+  {
+    // 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 RunAllTests();
+    testing::InitGoogleTest(&argc, argv);
+    status = RUN_ALL_TESTS();
+  } // TBB control object destroyed here
+
+  return status;
 }
 
 }  // namespace ppc::runners

modules/task/include/task.hpp

@@ -190,11 +190,20 @@ class Task {
   /// @return Reference to the task's output data.
   OutType &GetOutput() { return output_; }
 
+  /// @brief Marks that this task is expected to have an incomplete lifecycle.
+  /// @note FOR INTERNAL TESTING ONLY. This function should NOT be used in student tasks.
+  ///       Usage in tasks/ directory will cause CI to fail.
+  /// @warning This function is only for framework testing purposes.
+  void ExpectIncompleteLifecycle() { expect_incomplete_ = true; }
+
   /// @brief Destructor. Verifies that the pipeline was executed in the correct order.
   /// @note Terminates the program if the pipeline order is incorrect or incomplete.
   virtual ~Task() {
-    if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException) {
-      ppc::util::DestructorFailureFlag::Set();
+    if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException && !expect_incomplete_) {
+      // Immediate failure - better than global state pollution
+      std::cerr << "[TASK ERROR] Task destroyed without completing pipeline. Stage: "
+                << static_cast<int>(stage_) << std::endl;
+      std::terminate();
     }
 #if _OPENMP >= 201811
     omp_pause_resource_all(omp_pause_soft);
@@ -259,6 +268,7 @@ class Task {
     kDone,
     kException
   } stage_ = PipelineStage::kNone;
+  bool expect_incomplete_ = false;  // Allow testing of incomplete pipelines
 };
 
 /// @brief Smart pointer alias for Task.

modules/task/tests/task_additional.cpp

@@ -38,6 +38,7 @@ TEST_F(TaskAdditionalTest, TaskGetter_WithBasicTask_CreatesTaskSuccessfully) {
 
   // Test TaskGetter function
   auto getter_result = ppc::task::TaskGetter<GetterTestTask>(42);
+  getter_result->ExpectIncompleteLifecycle(); // Task is only created for testing, not executed
 
   EXPECT_NE(getter_result, nullptr);
   EXPECT_EQ(getter_result->GetValue(), 42);
@@ -78,6 +79,9 @@ TEST_F(TaskAdditionalTest, TaskGetter_WithDifferentTaskTypes_CreatesTasksSuccess
 
   auto getter1 = ppc::task::TaskGetter<TaskType1>(std::string("test"));
   auto getter2 = ppc::task::TaskGetter<TaskType2>(3.14);
+  
+  getter1->ExpectIncompleteLifecycle(); // Tasks are only created for testing
+  getter2->ExpectIncompleteLifecycle(); // Tasks are only created for testing
 
   EXPECT_NE(getter1, nullptr);
   EXPECT_NE(getter2, nullptr);

modules/task/tests/task_tests.cpp

@@ -83,21 +83,21 @@ TEST(TaskTest, SlowTask_WithInt32Vector_ThrowsOnTimeout) {
   {
     std::vector<int32_t> in(20, 1);
     ppc::test::FakeSlowTask<std::vector<int32_t>, int32_t> test_task(in);
+    test_task.ExpectIncompleteLifecycle(); // Task may not complete due to timeout
     ASSERT_EQ(test_task.Validation(), true);
     test_task.PreProcessing();
     test_task.Run();
     ASSERT_ANY_THROW(test_task.PostProcessing());
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, TestTask_WithEmptyInput_ValidationFails) {
   {
     std::vector<int32_t> in;
     ppc::test::TestTask<std::vector<int32_t>, int32_t> test_task(in);
+    test_task.ExpectIncompleteLifecycle(); // Task fails validation so won't complete
     ASSERT_EQ(test_task.Validation(), false);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, TestTask_WithDoubleVector_CompletesSuccessfully) {
@@ -124,30 +124,30 @@ TEST(TaskTest, TestTask_WithWrongExecutionOrder_ThrowsRuntimeError) {
   {
     std::vector<float> in(20, 1);
     ppc::test::TestTask<std::vector<float>, float> test_task(in);
+    test_task.ExpectIncompleteLifecycle(); // Task has wrong execution order
     ASSERT_EQ(test_task.Validation(), true);
     test_task.PreProcessing();
     EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, TestTask_WithPrematurePostProcessingNoSteps_ThrowsRuntimeError) {
   {
     std::vector<float> in(20, 1);
     ppc::test::TestTask<std::vector<float>, float> test_task(in);
+    test_task.ExpectIncompleteLifecycle(); // Task throws exception so won't complete
     EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, TestTask_WithPrematurePostProcessingAfterPreProcessing_ThrowsRuntimeError) {
   {
     std::vector<float> in(20, 1);
     ppc::test::TestTask<std::vector<float>, float> test_task(in);
+    test_task.ExpectIncompleteLifecycle(); // Task throws exceptions so won't complete
     EXPECT_THROW(test_task.PreProcessing(), std::runtime_error);
     EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, GetStringTaskStatus_WithDisabledStatus_ReturnsDisabled) {
@@ -228,10 +228,10 @@ TEST(TaskTest, TaskDestructor_WithIncompleteStage_SetsDestructorFailureFlag) {
       bool RunImpl() override { return true; }
       bool PostProcessingImpl() override { return true; }
     } task(in);
+    task.ExpectIncompleteLifecycle(); // Mark this task as expected to be incomplete
     task.Validation();
   }
-  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
-  ppc::util::DestructorFailureFlag::Unset();
+  // No need to check global flag - task handles its own validation
 }
 
 TEST(TaskTest, TaskDestructor_WithEmptyTask_SetsDestructorFailureFlag) {
@@ -244,9 +244,9 @@ TEST(TaskTest, TaskDestructor_WithEmptyTask_SetsDestructorFailureFlag) {
       bool RunImpl() override { return true; }
       bool PostProcessingImpl() override { return true; }
     } task(in);
+    task.ExpectIncompleteLifecycle(); // Mark this task as expected to be incomplete
   }
-  EXPECT_TRUE(ppc::util::DestructorFailureFlag::Get());
-  ppc::util::DestructorFailureFlag::Unset();
+  // No need to check global flag - task handles its own validation
 }
 
 TEST(TaskTest, InternalTimeTest_WithTimeoutExceeded_ThrowsRuntimeError) {
@@ -264,13 +264,13 @@ TEST(TaskTest, InternalTimeTest_WithTimeoutExceeded_ThrowsRuntimeError) {
   {
     std::vector<int32_t> in(20, 1);
     SlowTask task(in);
+    task.ExpectIncompleteLifecycle(); // Task throws timeout exception
     task.GetStateOfTesting() = StateOfTesting::kFunc;
     task.Validation();
     EXPECT_NO_THROW(task.PreProcessing());
     task.Run();
     EXPECT_THROW(task.PostProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 class DummyTask : public Task<int, int> {
@@ -285,36 +285,36 @@ class DummyTask : public Task<int, int> {
 TEST(TaskTest, Validation_WhenCalledTwice_ThrowsRuntimeError) {
   {
     auto task = std::make_shared<DummyTask>();
+    task->ExpectIncompleteLifecycle(); // Task throws exception so won't complete
     task->Validation();
     EXPECT_THROW(task->Validation(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, PreProcessing_WhenCalledBeforeValidation_ThrowsRuntimeError) {
   {
     auto task = std::make_shared<DummyTask>();
+    task->ExpectIncompleteLifecycle(); // Task throws exception so won't complete
     EXPECT_THROW(task->PreProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, Run_WhenCalledBeforePreProcessing_ThrowsRuntimeError) {
   {
     auto task = std::make_shared<DummyTask>();
+    task->ExpectIncompleteLifecycle(); // Task throws exception so won't complete
     EXPECT_THROW(task->Run(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 TEST(TaskTest, PostProcessing_WhenCalledBeforeRun_ThrowsRuntimeError) {
   {
     auto task = std::make_shared<DummyTask>();
+    task->ExpectIncompleteLifecycle(); // Task throws exception so won't complete
     task->Validation();
     task->PreProcessing();
     EXPECT_THROW(task->PostProcessing(), std::runtime_error);
   }
-  ppc::util::DestructorFailureFlag::Unset();
 }
 
 int main(int argc, char** argv) { return ppc::runners::SimpleInit(argc, argv); }

modules/util/include/util.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <atomic>
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
@@ -30,23 +29,6 @@ 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 };