Refactor test parametrization and naming for clarity

Refactored test parameter structs and macros to enhance readability and flexibility, including the addition of `FuncTestParam` and `PerfTestParam` types. Updated test case naming conventions with custom functions for better identification. Simplified utility functions and macros for improved code maintainability.

Author: allnes

modules/core/util/include/test_util.hpp

@@ -7,21 +7,41 @@
 
 namespace ppc::util {
 
+enum FuncTestParamIndex : uint8_t { kTaskGetter, kNameTest, kAddParams };
+
+inline std::string GetStringParamName(ppc::core::PerfResults::TypeOfRunning type_of_running) {
+  if (type_of_running == core::PerfResults::kTaskRun) {
+    return "task_run";
+  }
+  if (type_of_running == core::PerfResults::kPipeline) {
+    return "pipeline";
+  }
+  return "none";
+}
+
+template <typename InType, typename OutType, typename AddParams = void>
+using FuncTestParam = std::tuple<std::function<ppc::core::TaskPtr<InType, OutType>(InType)>, std::string, AddParams>;
+
 template <typename InType, typename OutType>
-using TestParam = std::tuple<ppc::core::PerfResults::TypeOfRunning,
-                             std::function<ppc::core::TaskPtr<InType, OutType>(InType)>, std::string>;
+using PerfTestParam = FuncTestParam<InType, OutType, ppc::core::PerfResults::TypeOfRunning>;
 
 template <typename InType, typename OutType>
-class BaseRunPerfTests : public ::testing::TestWithParam<TestParam<InType, OutType>> {
+class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, OutType>> {
+ public:
+  static std::string CustomPerfTestName(const ::testing::TestParamInfo<PerfTestParam<InType, OutType>>& info) {
+    return ppc::util::GetStringParamName(std::get<FuncTestParamIndex::kAddParams>(info.param)) + "_" +
+           std::get<FuncTestParamIndex::kNameTest>(info.param);
+  }
+
  protected:
   virtual void SetPerfAttributes(ppc::core::PerfAttr& perf_attrs) = 0;
   virtual bool CheckTestOutputData(OutType& output_data) = 0;
   virtual InType GetTestInputData() = 0;
 
   void ExecuteTest(ppc::core::PerfResults::TypeOfRunning mode,
                    std::function<ppc::core::TaskPtr<InType, OutType>(InType)> task_getter, std::string test_name) {
-    task = task_getter(GetTestInputData());
-    ppc::core::Perf perf(task);
+    task_ = task_getter(GetTestInputData());
+    ppc::core::Perf perf(task_);
     ppc::core::PerfAttr perf_attr;
     SetPerfAttributes(perf_attr);
 
@@ -40,18 +60,18 @@ class BaseRunPerfTests : public ::testing::TestWithParam<TestParam<InType, OutTy
     if (rank == 0) {
       perf.PrintPerfStatistic(test_name);
     }
-    OutType output_data = task->GetOutput();
+    OutType output_data = task_->GetOutput();
     ASSERT_TRUE(CheckTestOutputData(output_data));
   }
 
  private:
-  ppc::core::TaskPtr<InType, OutType> task;
+  ppc::core::TaskPtr<InType, OutType> task_;
 };
 
-#define ADD_MODES(TaskType, InputTypeParam)                                                                          \
-  std::make_tuple(ppc::core::PerfResults::TypeOfRunning::kPipeline, ppc::core::TaskGetter<TaskType, InputTypeParam>, \
-                  ppc::util::GetNamespace<TaskType>()),                                                              \
-      std::make_tuple(ppc::core::PerfResults::TypeOfRunning::kTaskRun,                                               \
-                      ppc::core::TaskGetter<TaskType, InputTypeParam>, ppc::util::GetNamespace<TaskType>())
+#define ADD_PERF_MODES(TaskType, InputTypeParam)                                                            \
+  std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>, ppc::util::GetNamespace<TaskType>(),     \
+                  ppc::core::PerfResults::TypeOfRunning::kPipeline),                                        \
+      std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>, ppc::util::GetNamespace<TaskType>(), \
+                      ppc::core::PerfResults::TypeOfRunning::kTaskRun)
 
 }  // namespace ppc::util

modules/core/util/include/util.hpp

@@ -3,8 +3,8 @@
 #include <string_view>
 
 /* NOLINTBEGIN */
-#define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \
-  INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator)
+#define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator, custom_test_name) \
+  INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator, custom_test_name)
 /* NOLINTEND */
 
 /* NOLINTBEGIN */
@@ -16,29 +16,35 @@ namespace ppc::util {
 std::string GetAbsolutePath(const std::string &relative_path);
 int GetPPCNumThreads();
 
+#if defined(__clang__) || defined(__GNUC__)
 template <typename T>
 consteval std::string_view GetNamespace() {
-#if defined(__clang__) || defined(__GNUC__)
-  constexpr std::string_view func = __PRETTY_FUNCTION__;
+  constexpr std::string_view kFunc = __PRETTY_FUNCTION__;
   // example: "consteval std::string_view get_namespace() [with T = my_namespace::MyClass]"
-  constexpr std::string_view key = "T = ";
+  constexpr std::string_view kKey = "T = ";
 #elif defined(_MSC_VER)
-  constexpr std::string_view func = __FUNCSIG__;
+template <typename T>
+constexpr std::string_view GetNamespace() {
+  constexpr std::string_view kFunc = __FUNCSIG__;
   // example: "class std::basic_string_view<char,struct std::char_traits<char> > __cdecl get_namespace<class
   // my_namespace::MyClass>(void)"
-  constexpr std::string_view key = "get_namespace<";
+  constexpr std::string_view kKey = "get_namespace<";
 #else
-  static_assert(false, "Unsupported compiler");
+static_assert(false, "Unsupported compiler");
 #endif
 
-  auto start = func.find(key);
-  if (start == std::string_view::npos) return {};
-  start += key.size();
+  auto start = kFunc.find(kKey);
+  if (start == std::string_view::npos) {
+    return {};
+  }
+  start += kKey.size();
 
-  auto end = func.find("::", start);
-  if (end == std::string_view::npos) return {};
+  auto end = kFunc.find("::", start);
+  if (end == std::string_view::npos) {
+    return {};
+  }
 
-  return func.substr(start, end - start);
+  return kFunc.substr(start, end - start);
 }
 
 }  // namespace ppc::util

tasks/example/tests/func_tests/main.cpp

@@ -1,10 +1,12 @@
 #include <gtest/gtest.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <stb_library.hpp>
 #include <string>
 #include <vector>
 
+#include "core/util/include/test_util.hpp"
 #include "core/util/include/util.hpp"
 #include "example/all/include/ops_all.hpp"
 #include "example/mpi/include/ops_mpi.hpp"
@@ -16,25 +18,29 @@
 using InType = std::vector<int>;
 using OutType = std::vector<int>;
 
-using TestParam = std::tuple<int, std::function<ppc::core::TaskPtr<InType, OutType>(InType)>>;
+class NesterovARunFuncTests : public ::testing::TestWithParam<ppc::util::FuncTestParam<InType, OutType, int>> {
+ public:
+  static std::string CustomFuncTestName(
+      const ::testing::TestParamInfo<ppc::util::FuncTestParam<InType, OutType, int>>& info) {
+    return std::to_string(info.index);
+  }
 
-class NesterovARunFuncTests : public ::testing::TestWithParam<TestParam> {
  protected:
   void SetUp() override {
     // Read image
     std::string abs_path = ppc::util::GetAbsolutePath("example/tests/data/pic_all.jpg");
     data = stbi_load(abs_path.c_str(), &width, &height, &channels, 0);
     ASSERT_TRUE(data != nullptr) << "Failed to load image: " << stbi_failure_reason();
-    img = std::vector<uint8_t>(data, data + (width * height * channels));
+    img = std::vector<uint8_t>(data, data + (static_cast<ptrdiff_t>(width * height * channels)));
     stbi_image_free(data);
     ASSERT_EQ(width, height);
 
-    const int k_count = (width + height) / std::get<0>(GetParam());
-    std::vector<int> in(k_count * k_count, 0);
+    const int k_count = (width + height) / std::get<ppc::util::FuncTestParamIndex::kAddParams>(GetParam());
+    std::vector<int> in(static_cast<std::vector<int>::size_type>(k_count * k_count), 0);
     for (int i = 0; i < k_count; i++) {
       in[(i * k_count) + i] = 1;
     }
-    task = std::get<1>(GetParam())(in);
+    task = std::get<ppc::util::FuncTestParamIndex::kTaskGetter>(GetParam())(in);
   }
 
   void ExecuteTest() {
@@ -53,13 +59,15 @@ class NesterovARunFuncTests : public ::testing::TestWithParam<TestParam> {
 
 TEST_P(NesterovARunFuncTests, MatmulFromPic) { ExecuteTest(); }
 
-#define ADD_TASK(TASK) \
-  std::make_tuple(5, ppc::core::TaskGetter<TASK, InType>), std::make_tuple(10, ppc::core::TaskGetter<TASK, InType>)
+#define ADD_FUNC_TASK(TASK)                                    \
+  std::make_tuple(ppc::core::TaskGetter<TASK, InType>, "", 5), \
+      std::make_tuple(ppc::core::TaskGetter<TASK, InType>, "", 10)
 
 INSTANTIATE_TEST_SUITE_P_NOLINT(PicMatrixTests, NesterovARunFuncTests,
-                                ::testing::Values(ADD_TASK(nesterov_a_test_task_all::TestTaskALL),
-                                                  ADD_TASK(nesterov_a_test_task_mpi::TestTaskMPI),
-                                                  ADD_TASK(nesterov_a_test_task_omp::TestTaskOMP),
-                                                  ADD_TASK(nesterov_a_test_task_seq::TestTaskSEQ),
-                                                  ADD_TASK(nesterov_a_test_task_stl::TestTaskSTL),
-                                                  ADD_TASK(nesterov_a_test_task_tbb::TestTaskTBB)));
+                                ::testing::Values(ADD_FUNC_TASK(nesterov_a_test_task_all::TestTaskALL),
+                                                  ADD_FUNC_TASK(nesterov_a_test_task_mpi::TestTaskMPI),
+                                                  ADD_FUNC_TASK(nesterov_a_test_task_omp::TestTaskOMP),
+                                                  ADD_FUNC_TASK(nesterov_a_test_task_seq::TestTaskSEQ),
+                                                  ADD_FUNC_TASK(nesterov_a_test_task_stl::TestTaskSTL),
+                                                  ADD_FUNC_TASK(nesterov_a_test_task_tbb::TestTaskTBB)),
+                                NesterovARunFuncTests::CustomFuncTestName);

tasks/example/tests/perf_tests/main.cpp

@@ -20,12 +20,12 @@ using OutType = std::vector<int>;
 
 class ExampleRunPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
   static constexpr int kCount = 400;
-  InType input_data;
+  InType input_data_;
 
   void SetUp() override {
-    input_data.assign(kCount * kCount, 0);
+    input_data_.assign(kCount * kCount, 0);
     for (int i = 0; i < kCount; ++i) {
-      input_data[(i * kCount) + i] = 1;
+      input_data_[(i * kCount) + i] = 1;
     }
   }
 
@@ -38,19 +38,23 @@ class ExampleRunPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
     };
   }
 
-  bool CheckTestOutputData(OutType& output_data) final { return input_data == output_data; }
+  bool CheckTestOutputData(OutType& output_data) final { return input_data_ == output_data; }
 
-  InType GetTestInputData() final { return input_data; }
+  InType GetTestInputData() final { return input_data_; }
 };
 
 TEST_P(ExampleRunPerfTest, RunModes) {
-  ExecuteTest(std::get<0>(GetParam()), std::get<1>(GetParam()), std::get<2>(GetParam()));
+  auto task_getter = std::get<ppc::util::FuncTestParamIndex::kTaskGetter>(GetParam());
+  auto test_name = std::get<ppc::util::FuncTestParamIndex::kNameTest>(GetParam());
+  auto perf_type = std::get<ppc::util::FuncTestParamIndex::kAddParams>(GetParam());
+  ExecuteTest(perf_type, task_getter, test_name);
 }
 
 INSTANTIATE_TEST_SUITE_P_NOLINT(RunModeTests, ExampleRunPerfTest,
-                                ::testing::Values(ADD_MODES(nesterov_a_test_task_all::TestTaskALL, InType),
-                                                  ADD_MODES(nesterov_a_test_task_mpi::TestTaskMPI, InType),
-                                                  ADD_MODES(nesterov_a_test_task_omp::TestTaskOMP, InType),
-                                                  ADD_MODES(nesterov_a_test_task_seq::TestTaskSEQ, InType),
-                                                  ADD_MODES(nesterov_a_test_task_stl::TestTaskSTL, InType),
-                                                  ADD_MODES(nesterov_a_test_task_tbb::TestTaskTBB, InType)));
+                                ::testing::Values(ADD_PERF_MODES(nesterov_a_test_task_all::TestTaskALL, InType),
+                                                  ADD_PERF_MODES(nesterov_a_test_task_mpi::TestTaskMPI, InType),
+                                                  ADD_PERF_MODES(nesterov_a_test_task_omp::TestTaskOMP, InType),
+                                                  ADD_PERF_MODES(nesterov_a_test_task_seq::TestTaskSEQ, InType),
+                                                  ADD_PERF_MODES(nesterov_a_test_task_stl::TestTaskSTL, InType),
+                                                  ADD_PERF_MODES(nesterov_a_test_task_tbb::TestTaskTBB, InType)),
+                                ExampleRunPerfTest::CustomPerfTestName);