update Task tests and implementation: replace EXPECT_DEATH_IF_SUPPORTED with EXPECT_THROW, add kException pipeline stage, and improve error handling in Task destructor

Author: allnes

modules/core/performance/tests/perf_tests.cpp

@@ -238,12 +238,8 @@ TEST(TaskTest, GetDynamicTypeReturnsCorrectEnum) {
 }
 
 TEST(TaskTest, DestructorTerminatesIfWrongOrder) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
-  auto test_func = [&] {
-    DummyTask task;
-    task.Run();
-  };
-  ASSERT_DEATH_IF_SUPPORTED({ test_func(); }, "");
+  DummyTask task;
+  EXPECT_THROW(task.Run(), std::runtime_error);
 }
 
 namespace my {

modules/core/task/include/task.hpp

@@ -114,6 +114,7 @@ class Task {
     if (stage_ == PipelineStage::kNone || stage_ == PipelineStage::kDone) {
       stage_ = PipelineStage::kValidation;
     } else {
+      stage_ = PipelineStage::kException;
       throw std::runtime_error("Validation should be called before preprocessing");
     }
     return ValidationImpl();
@@ -125,6 +126,7 @@ class Task {
     if (stage_ == PipelineStage::kValidation) {
       stage_ = PipelineStage::kPreProcessing;
     } else {
+      stage_ = PipelineStage::kException;
       throw std::runtime_error("Preprocessing should be called after validation");
     }
     if (state_of_testing_ == StateOfTesting::kFunc) {
@@ -139,6 +141,7 @@ class Task {
     if (stage_ == PipelineStage::kPreProcessing || stage_ == PipelineStage::kRun) {
       stage_ = PipelineStage::kRun;
     } else {
+      stage_ = PipelineStage::kException;
       throw std::runtime_error("Run should be called after preprocessing");
     }
     return RunImpl();
@@ -150,6 +153,7 @@ class Task {
     if (stage_ == PipelineStage::kRun) {
       stage_ = PipelineStage::kDone;
     } else {
+      stage_ = PipelineStage::kException;
       throw std::runtime_error("Postprocessing should be called after run");
     }
     if (state_of_testing_ == StateOfTesting::kFunc) {
@@ -189,7 +193,7 @@ class Task {
   /// @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) {
+    if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException) {
       std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT" << '\n';
       std::terminate();
     }
@@ -248,7 +252,14 @@ class Task {
   StatusOfTask status_of_task_ = kEnabled;
   static constexpr double kMaxTestTime = 1.0;
   std::chrono::high_resolution_clock::time_point tmp_time_point_;
-  enum class PipelineStage : uint8_t { kNone, kValidation, kPreProcessing, kRun, kDone } stage_ = PipelineStage::kNone;
+  enum class PipelineStage : uint8_t {
+    kNone,
+    kValidation,
+    kPreProcessing,
+    kRun,
+    kDone,
+    kException
+  } stage_ = PipelineStage::kNone;
 };
 
 /// @brief Smart pointer alias for Task.

modules/core/task/tests/task_tests.cpp

@@ -62,33 +62,24 @@ TEST(task_tests, check_float) {
 }
 
 TEST(task_tests, check_wrong_order_disabled_valgrind) {
-  auto destroy_function = [] {
-    std::vector<float> in(20, 1);
-    ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
-    ASSERT_EQ(test_task.Validation(), true);
-    test_task.PreProcessing();
-    test_task.PostProcessing();
-  };
-  EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+  std::vector<float> in(20, 1);
+  ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
+  ASSERT_EQ(test_task.Validation(), true);
+  test_task.PreProcessing();
+  EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
 }
 
 TEST(task_tests, premature_postprocessing_no_steps) {
-  auto destroy_function = [] {
-    std::vector<float> in(20, 1);
-    ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
-    ASSERT_NO_THROW(test_task.PostProcessing());
-  };
-  EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+  std::vector<float> in(20, 1);
+  ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
+  EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
 }
 
 TEST(task_tests, premature_postprocessing_after_preprocessing) {
-  auto destroy_function = [] {
-    std::vector<float> in(20, 1);
-    ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
-    ASSERT_NO_THROW(test_task.PreProcessing());
-    ASSERT_NO_THROW(test_task.PostProcessing());
-  };
-  EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+  std::vector<float> in(20, 1);
+  ppc::test::task::TestTask<std::vector<float>, float> test_task(in);
+  EXPECT_THROW(test_task.PreProcessing(), std::runtime_error);
+  EXPECT_THROW(test_task.PostProcessing(), std::runtime_error);
 }
 
 TEST(TaskTest, GetStringTaskStatus_Disabled) {
@@ -201,38 +192,26 @@ class DummyTask : public ppc::core::Task<int, int> {
 };
 
 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");
+  auto task = std::make_shared<DummyTask>();
+  task->Validation();
+  EXPECT_THROW(task->Validation(), std::runtime_error);
 }
 
 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");
+  auto task = std::make_shared<DummyTask>();
+  EXPECT_THROW(task->PreProcessing(), std::runtime_error);
 }
 
 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");
+  auto task = std::make_shared<DummyTask>();
+  EXPECT_THROW(task->Run(), std::runtime_error);
 }
 
 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");
+  auto task = std::make_shared<DummyTask>();
+  task->Validation();
+  task->PreProcessing();
+  EXPECT_THROW(task->PostProcessing(), std::runtime_error);
 }
 
 int main(int argc, char** argv) {