add tests for Task pipeline stage order validation and update Task methods to enforce correct call sequence

Author: allnes

modules/core/task/include/task.hpp

@@ -111,8 +111,10 @@ class Task {
   /// @brief Validates input data and task attributes before execution.
   /// @return True if validation is successful.
   virtual bool Validation() final {
-    if (stage_ == PipelineStage::kNone) {
+    if (stage_ == PipelineStage::kNone || stage_ == PipelineStage::kDone) {
       stage_ = PipelineStage::kValidation;
+    } else {
+      throw std::runtime_error("Validation should be called before preprocessing");
     }
     return ValidationImpl();
   }
@@ -122,6 +124,8 @@ class Task {
   virtual bool PreProcessing() final {
     if (stage_ == PipelineStage::kValidation) {
       stage_ = PipelineStage::kPreProcessing;
+    } else {
+      throw std::runtime_error("Preprocessing should be called after validation");
     }
     if (state_of_testing_ == StateOfTesting::kFunc) {
       InternalTimeTest();
@@ -134,6 +138,8 @@ class Task {
   virtual bool Run() final {
     if (stage_ == PipelineStage::kPreProcessing || stage_ == PipelineStage::kRun) {
       stage_ = PipelineStage::kRun;
+    } else {
+      throw std::runtime_error("Run should be called after preprocessing");
     }
     return RunImpl();
   }
@@ -143,6 +149,8 @@ class Task {
   virtual bool PostProcessing() final {
     if (stage_ == PipelineStage::kRun) {
       stage_ = PipelineStage::kDone;
+    } else {
+      throw std::runtime_error("Postprocessing should be called after run");
     }
     if (state_of_testing_ == StateOfTesting::kFunc) {
       InternalTimeTest();

modules/core/task/tests/task_tests.cpp

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <exception>
 #include <fstream>
+#include <memory>
 #include <stdexcept>
 #include <thread>
 #include <vector>
@@ -190,6 +191,50 @@ TEST(TaskTest, InternalTimeTest_ThrowsIfTimeoutExceeded) {
   EXPECT_THROW(task.PostProcessing(), std::runtime_error);
 }
 
+class DummyTask : public ppc::core::Task<int, int> {
+ public:
+  using Task::Task;
+  bool ValidationImpl() override { return true; }
+  bool PreProcessingImpl() override { return true; }
+  bool RunImpl() override { return true; }
+  bool PostProcessingImpl() override { return true; }
+};
+
+TEST(TaskTest, ValidationThrowsIfCalledTwice) {
+  auto test_func = [&] {
+    auto task = std::make_shared<DummyTask>();
+    task->Validation();
+    EXPECT_THROW(task->Validation(), std::runtime_error);
+  };
+  EXPECT_DEATH_IF_SUPPORTED({ test_func(); }, "ORDER OF FUNCTIONS IS NOT RIGHT");
+}
+
+TEST(TaskTest, PreProcessingThrowsIfCalledBeforeValidation) {
+  auto test_func = [&] {
+    auto task = std::make_shared<DummyTask>();
+    EXPECT_THROW(task->PreProcessing(), std::runtime_error);
+  };
+  EXPECT_DEATH_IF_SUPPORTED({ test_func(); }, "ORDER OF FUNCTIONS IS NOT RIGHT");
+}
+
+TEST(TaskTest, RunThrowsIfCalledBeforePreProcessing) {
+  auto test_func = [&] {
+    auto task = std::make_shared<DummyTask>();
+    EXPECT_THROW(task->Run(), std::runtime_error);
+  };
+  EXPECT_DEATH_IF_SUPPORTED({ test_func(); }, "ORDER OF FUNCTIONS IS NOT RIGHT");
+}
+
+TEST(TaskTest, PostProcessingThrowsIfCalledBeforeRun) {
+  auto test_func = [&] {
+    auto task = std::make_shared<DummyTask>();
+    task->Validation();
+    task->PreProcessing();
+    EXPECT_THROW(task->PostProcessing(), std::runtime_error);
+  };
+  EXPECT_DEATH_IF_SUPPORTED({ test_func(); }, "ORDER OF FUNCTIONS IS NOT RIGHT");
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();