increase coverage

Author: allnes

modules/core/perf/src/perf.cpp

@@ -72,7 +72,7 @@ void ppc::core::Perf::PrintPerfStatistic(const std::shared_ptr<PerfResults>& per
     type_test_name = "task_run";
   } else if (perf_results->type_of_running == PerfResults::TypeOfRunning::kPipeline) {
     type_test_name = "pipeline";
-  } else if (perf_results->type_of_running == PerfResults::TypeOfRunning::kNone) {
+  } else {
     type_test_name = "none";
   }
 

modules/core/task/func_tests/task_tests.cpp

@@ -30,6 +30,28 @@ TEST(task_tests, check_int32_t) {
   ASSERT_EQ(static_cast<size_t>(out[0]), in.size());
 }
 
+TEST(task_tests, check_int32_t_slow) {
+  // Create data
+  std::vector<int32_t> in(20, 1);
+  std::vector<int32_t> out(1, 0);
+
+  // Create TaskData
+  auto task_data = std::make_shared<ppc::core::TaskData>();
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data->inputs_count.emplace_back(in.size());
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  ppc::test::task::FakeSlowTask<int32_t> test_task(task_data);
+  bool is_valid = test_task.Validation();
+  ASSERT_EQ(is_valid, true);
+  test_task.PreProcessing();
+  test_task.Run();
+  ASSERT_ANY_THROW(test_task.PostProcessing());
+  ASSERT_EQ(static_cast<size_t>(out[0]), in.size());
+}
+
 TEST(task_tests, check_validate_func) {
   // Create data
   std::vector<int32_t> in(20, 1);

modules/core/task/func_tests/test_task.hpp

@@ -1,9 +1,12 @@
 #pragma once
 
+#include <thread>
 #include <vector>
 
 #include "core/task/include/task.hpp"
 
+using namespace std::chrono_literals;
+
 namespace ppc::test::task {
 
 template <class T>
@@ -33,4 +36,15 @@ class TestTask : public ppc::core::Task {
   T *output_{};
 };
 
+template <class T>
+class FakeSlowTask : public TestTask<T> {
+ public:
+  explicit FakeSlowTask(ppc::core::TaskDataPtr perf_task_data) : TestTask<T>(perf_task_data) {}
+
+  bool RunImpl() override {
+    std::this_thread::sleep_for(5000ms);
+    return TestTask<T>::RunImpl();
+  }
+};
+
 }  // namespace ppc::test::task

modules/core/task/src/task.cpp

@@ -1,13 +1,10 @@
 #include "core/task/include/task.hpp"
 
-#include <gtest/gtest.h>
-
-#include <chrono>
 #include <cstddef>
+#include <iomanip>
 #include <iostream>
 #include <stdexcept>
 #include <string>
-#include <utility>
 
 void ppc::core::Task::SetData(TaskDataPtr task_data_ptr) {
   task_data_ptr->state_of_testing = TaskData::StateOfTesting::kFunc;
@@ -58,13 +55,18 @@ void ppc::core::Task::InternalOrderTest(const std::string& str) {
     tmp_time_point_ = std::chrono::high_resolution_clock::now();
   }
 
-  if (str == "post_processing" && task_data->state_of_testing == TaskData::StateOfTesting::kFunc) {
+  if (str == "PostProcessing" && task_data->state_of_testing == TaskData::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 (current_time > max_test_time_) {
-      std::cerr << "Current test work more than " << max_test_time_ << " secs: " << current_time << '\n';
-      EXPECT_TRUE(current_time < max_test_time_);
+    if (current_time < max_test_time_) {
+      std::cout << "Test time:" << std::fixed << std::setprecision(10) << current_time;
+    } else {
+      std::stringstream err_msg;
+      err_msg << "\nTask execute time need to be: ";
+      err_msg << "time < " << max_test_time_ << " secs.\n";
+      err_msg << "Original time in secs: " << current_time << '\n';
+      throw std::runtime_error(err_msg.str().c_str());
     }
   }
 }