fix coverage 3

Author: allnes

modules/core/task/func_tests/task_tests.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "core/task/func_tests/test_task.hpp"
+#include "core/util/include/util.hpp"
 
 TEST(task_tests, check_int32_t) {
   // Create data
@@ -50,6 +51,10 @@ TEST(task_tests, check_validate_func) {
 
   // Check Result
   ASSERT_EQ(is_valid, false);
+
+  test_task.PreProcessing();
+  test_task.Run();
+  test_task.PostProcessing();
 }
 
 TEST(task_tests, check_double) {
@@ -124,18 +129,30 @@ TEST(task_tests, check_float) {
   EXPECT_NEAR(test_task.Get(), in.size(), 1e-3);
 }
 
-TEST(task_tests, check_wrong_order) {
-  // Create data
-  std::vector<float> in(20, 1);
+DEATH_TEST(task_tests, check_wrong_order) {
+  auto destroy_function = [] {
+    // Create data
+    std::vector<float> in(20, 1);
+
+    // Create Task
+    ppc::test::task::TestTask<float> test_task(in);
+    bool is_valid = test_task.Validation();
+    ASSERT_EQ(is_valid, true);
+    test_task.PreProcessing();
+    test_task.PostProcessing();
+  };
+  EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
+}
 
-  // Create Task
-  ppc::test::task::TestTask<float> test_task(in);
-  bool is_valid = test_task.Validation();
-  ASSERT_EQ(is_valid, true);
+DEATH_TEST(task_tests, check_empty_order) {
+  auto destroy_function = [] {
+    // Create data
+    std::vector<float> in(20, 1);
 
-  // Run Task
-  test_task.PreProcessing();
-  ASSERT_ANY_THROW(test_task.PostProcessing());
+    // Create Task
+    ppc::test::task::TestTask<float> test_task(in);
+  };
+  EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
 }
 
 int main(int argc, char **argv) {

modules/core/task/include/task.hpp

@@ -34,7 +34,9 @@ class Task {
   virtual ~Task();
 
  protected:
-  virtual void InternalOrderTest(const std::string &str = __builtin_FUNCTION()) final;
+  virtual void InternalOrderTest(const std::string &str) final;
+
+  virtual void InternalTimeTest(const std::string &str) final;
 
   // implementation of "Validation" function
   virtual bool ValidationImpl() = 0;
@@ -54,7 +56,9 @@ class Task {
   std::vector<std::string> right_functions_order_ = {"Validation", "PreProcessing", "Run", "PostProcessing"};
   static constexpr double kMaxTestTime = 1.0;
   std::chrono::high_resolution_clock::time_point tmp_time_point_;
-  bool functions_order_validation_ = true;
+  bool was_worked_ = false;
+
+  bool IsFullPipelineStage();
 };
 
 }  // namespace ppc::core

modules/core/task/src/task.cpp

@@ -1,90 +1,101 @@
 #include "core/task/include/task.hpp"
 
+#include <algorithm>
 #include <chrono>
 #include <cstddef>
 #include <exception>
+#include <functional>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <utility>
 
+using namespace std::chrono;
+
 ppc::core::Task::Task(StateOfTesting state_of_testing) : state_of_testing_(state_of_testing) {
   functions_order_.clear();
 }
 
 bool ppc::core::Task::Validation() {
-  InternalOrderTest();
+  InternalOrderTest(__builtin_FUNCTION());
   return ValidationImpl();
 }
 
 bool ppc::core::Task::PreProcessing() {
-  InternalOrderTest();
+  InternalOrderTest(__builtin_FUNCTION());
+  if (state_of_testing_ == StateOfTesting::kFunc) {
+    InternalTimeTest(__builtin_FUNCTION());
+  }
   return PreProcessingImpl();
 }
 
 bool ppc::core::Task::Run() {
-  InternalOrderTest();
+  InternalOrderTest(__builtin_FUNCTION());
   return RunImpl();
 }
 
 bool ppc::core::Task::PostProcessing() {
-  InternalOrderTest();
+  InternalOrderTest(__builtin_FUNCTION());
+  if (state_of_testing_ == StateOfTesting::kFunc) {
+    InternalTimeTest(__builtin_FUNCTION());
+  }
   return PostProcessingImpl();
 }
 
-void ppc::core::Task::InternalOrderTest(const std::string& str) {
-  if (!functions_order_.empty() && str == functions_order_.back() && str == "Run") {
-    return;
-  }
-
+void ppc::core::Task::InternalOrderTest(const std::string &str) {
   functions_order_.push_back(str);
-
-  for (size_t i = 0; i < functions_order_.size(); i++) {
-    if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) {
-      functions_order_validation_ = false;
-      throw std::invalid_argument("ORDER OF FUNCTIONS IS NOT RIGHT: \n" + std::string("Serial number: ") +
-                                  std::to_string(i + 1) + "\n" + std::string("Your function: ") + functions_order_[i] +
-                                  "\n" + std::string("Expected function: ") + right_functions_order_[i]);
-    }
+  if (str == "PostProcessing" && IsFullPipelineStage()) {
+    functions_order_.clear();
+  } else {
+    was_worked_ = true;
   }
+}
 
-  if (str == "PreProcessing" && state_of_testing_ == StateOfTesting::kFunc) {
+void ppc::core::Task::InternalTimeTest(const std::string &str) {
+  if (str == "PreProcessing") {
     tmp_time_point_ = std::chrono::high_resolution_clock::now();
   }
 
-  if (str == "PostProcessing" && state_of_testing_ == StateOfTesting::kFunc) {
-    auto end = std::chrono::high_resolution_clock::now();
-    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - tmp_time_point_).count();
-    auto current_time = static_cast<double>(duration) * 1e-9;
+  if (str == "PostProcessing") {
+    auto duration = duration_cast<nanoseconds>(high_resolution_clock::now() - tmp_time_point_).count();
+    auto diff = static_cast<double>(duration) * 1e-9;
+
     std::stringstream err_msg;
-    if (current_time < kMaxTestTime) {
-      err_msg << "Test time:" << std::fixed << std::setprecision(10) << current_time;
+    if (diff < kMaxTestTime) {
+      err_msg << "Test time:" << std::fixed << std::setprecision(10) << diff;
     } else {
       err_msg << "\nTask execute time need to be: ";
       err_msg << "time < " << kMaxTestTime << " secs.\n";
-      err_msg << "Original time in secs: " << current_time << '\n';
+      err_msg << "Original time in secs: " << diff << '\n';
       throw std::runtime_error(err_msg.str().c_str());
     }
   }
 }
 
+bool ppc::core::Task::IsFullPipelineStage() {
+  auto it = std::adjacent_find(functions_order_.begin() + 2,
+                               functions_order_.begin() + static_cast<long>(functions_order_.size() - 2),
+                               std::not_equal_to<>());
+
+  return (functions_order_.size() >= 4 && functions_order_[0] == "Validation" &&
+          functions_order_[1] == "PreProcessing" && functions_order_[2] == "Run" &&
+          it == (functions_order_.begin() + static_cast<long>(functions_order_.size() - 2)) &&
+          functions_order_[functions_order_.size() - 1] == "PostProcessing");
+}
+
 ppc::core::Task::~Task() {
-  if (functions_order_.empty()) {
-    std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: No task functions were executed\n";
+  auto custom_terminate = []() {
+    std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT! \n"
+                 "Expected - \"Validation\", \"PreProcessing\", \"Run\", \"PostProcessing\" \n";
+    std::exit(404);
+  };
+  std::set_terminate(custom_terminate);
+
+  if (!functions_order_.empty() || !was_worked_) {
     std::terminate();
+  } else {
+    functions_order_.clear();
   }
-  if (functions_order_validation_) {
-    for (size_t i = 0; i < functions_order_.size(); i++) {
-      if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) {
-        std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: \n"
-                  << std::string("Serial number: ") << std::to_string(i + 1) << "\n"
-                  << std::string("Your function: ") << functions_order_[i] << "\n"
-                  << std::string("Expected function: ") << right_functions_order_[i] << "\n";
-        std::terminate();
-      }
-    }
-  }
-  functions_order_.clear();
 }

modules/core/util/include/util.hpp

@@ -5,6 +5,9 @@
 #define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \
   INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator)  // NOLINT
 
+// NOLINTNEXTLINE
+#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name)  // NOLINT
+
 namespace ppc::util {
 
 std::string GetAbsolutePath(const std::string &relative_path);