Standardize and refactor test macros:

- Replace `DEATH_TEST` with `TEST_NOLINT` and introduce consistent `NOLINT` test macro variants (`ASSERT_DEATH_IF_SUPPORTED_NOLINT`, `TYPED_TEST_NOLINT`, etc.).
- Update affected test cases in `task_tests.cpp`, `perf_tests.cpp`, and `util.hpp`.
- Enhance `GetNamespaceTest` consistency with variable naming improvements.
- Include missing `util.hpp` in performance tests and clean up redundant includes.

Author: allnes

modules/core/performance/tests/perf_tests.cpp

@@ -7,6 +7,7 @@
 
 #include "core/performance/include/performance.hpp"
 #include "core/performance/tests/test_task.hpp"
+#include "core/util/include/util.hpp"
 
 TEST(perf_tests, check_perf_pipeline) {
   std::vector<uint32_t> in(2000, 1);
@@ -99,7 +100,7 @@ TEST_P(GetStringParamNameParamTest, ReturnsExpectedString) {
   EXPECT_EQ(ppc::core::GetStringParamName(param.input), param.expected_output);
 }
 
-INSTANTIATE_TEST_SUITE_P(ParamTests, GetStringParamNameParamTest,
+INSTANTIATE_TEST_SUITE_P_NOLINT(ParamTests, GetStringParamNameParamTest,
                          ::testing::Values(ParamTestCase{ppc::core::PerfResults::kTaskRun, "task_run"},
                                            ParamTestCase{ppc::core::PerfResults::kPipeline, "pipeline"},
                                            ParamTestCase{static_cast<ppc::core::PerfResults::TypeOfRunning>(999),
@@ -144,7 +145,7 @@ INSTANTIATE_TEST_SUITE_P_NOLINT(AllTypeCases, GetStringTaskTypeTest,
                                                   TaskTypeTestCase{ppc::core::TypeOfTask::kTBB, "tbb_TBB", "kTBB"},
                                                   TaskTypeTestCase{ppc::core::TypeOfTask::kSEQ, "seq_SEQ", "kSEQ"}));
 
-DEATH_TEST(GetStringTaskTypeStandaloneTest, ThrowsIfFileMissing) {
+TEST_NOLINT(GetStringTaskTypeStandaloneTest, ThrowsIfFileMissing) {
   std::string missing_path = "non_existent_settings.json";
   EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, missing_path), std::runtime_error);
 }
@@ -159,12 +160,12 @@ TEST(GetStringTaskTypeStandaloneTest, ReturnsUnknownForInvalidEnum) {
   std::filesystem::remove(path);
 }
 
-TEST(GetStringTaskTypeEdgeCases, ThrowsIfFileCannotBeOpened) {
+TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfFileCannotBeOpened) {
   EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, "definitely_missing_file.json"),
                       std::runtime_error);
 }
 
-TEST(GetStringTaskTypeEdgeCases, ThrowsIfJsonIsMalformed) {
+TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfJsonIsMalformed) {
   std::string path = std::filesystem::temp_directory_path() / "bad_json.json";
   std::ofstream(path) << "{ this is not valid json ";
   EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), nlohmann::json::parse_error);
@@ -175,7 +176,7 @@ TEST(GetStringTaskTypeEdgeCases, ThrowsIfJsonValueIsNull) {
   std::string path = std::filesystem::temp_directory_path() / "null_value.json";
   std::ofstream(path) << R"({"tasks": { "seq": null }})";
 
-  EXPECT_THROW(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), nlohmann::json::type_error);
+  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), nlohmann::json::type_error);
 
   std::filesystem::remove(path);
 }
@@ -224,9 +225,9 @@ TEST(TaskTest, GetDynamicTypeReturnsCorrectEnum) {
   EXPECT_EQ(task.GetDynamicTypeOfTask(), ppc::core::TypeOfTask::kOMP);
 }
 
-DEATH_TEST(TaskTest, DestructorTerminatesIfWrongOrder) {
+TEST_NOLINT(TaskTest, DestructorTerminatesIfWrongOrder) {
   testing::FLAGS_gtest_death_test_style = "threadsafe";
-  ASSERT_DEATH_IF_SUPPORTED(
+  ASSERT_DEATH_IF_SUPPORTED_NOLINT(
       {
         DummyTask task;
         task.Run();
@@ -249,17 +250,17 @@ using TestTypes = ::testing::Types<my::nested::Type, my::Another, int, std::vect
 
 TYPED_TEST_SUITE(GetNamespaceTest, TestTypes);
 
-TYPED_TEST(GetNamespaceTest, ExtractsNamespaceCorrectly) {
-  constexpr std::string_view ns = ppc::util::GetNamespace<TypeParam>();
+TYPED_TEST_NOLINT(GetNamespaceTest, ExtractsNamespaceCorrectly) {
+  constexpr std::string_view kNs = ppc::util::GetNamespace<TypeParam>();
 
   if constexpr (std::is_same_v<TypeParam, my::nested::Type>) {
-    EXPECT_EQ(ns, "my::nested");
+    EXPECT_EQ(kNs, "my::nested");
   } else if constexpr (std::is_same_v<TypeParam, my::Another>) {
-    EXPECT_EQ(ns, "my");
+    EXPECT_EQ(kNs, "my");
   } else if constexpr (std::is_same_v<TypeParam, int>) {
-    EXPECT_EQ(ns, "");
+    EXPECT_EQ(kNs, "");
   } else if constexpr (std::is_same_v<TypeParam, std::vector<int>>) {
-    EXPECT_EQ(ns, "std");
+    EXPECT_EQ(kNs, "std");
   } else {
     FAIL() << "Unhandled type in test";
   }

modules/core/performance/tests/test_task.hpp

@@ -2,7 +2,6 @@
 
 #include <chrono>
 #include <thread>
-#include <vector>
 
 #include "core/task/include/task.hpp"
 

modules/core/task/tests/task_tests.cpp

@@ -128,7 +128,7 @@ TEST(task_tests, check_float) {
   EXPECT_NEAR(test_task.GetOutput(), in.size(), 1e-3);
 }
 
-DEATH_TEST(task_tests, check_wrong_order_disabled_valgrind) {
+TEST_NOLINT(task_tests, check_wrong_order_disabled_valgrind) {
   auto destroy_function = [] {
     // Create data
     std::vector<float> in(20, 1);
@@ -143,7 +143,7 @@ DEATH_TEST(task_tests, check_wrong_order_disabled_valgrind) {
   EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
 }
 
-DEATH_TEST(task_tests, check_empty_order_disabled_valgrind) {
+TEST_NOLINT(task_tests, check_empty_order_disabled_valgrind) {
   auto destroy_function = [] {
     // Create data
     std::vector<float> in(20, 1);

modules/core/util/include/util.hpp

@@ -30,7 +30,15 @@
 /* NOLINTEND */
 
 /* NOLINTBEGIN */
-#define DEATH_TEST(...) TEST(__VA_ARGS__)
+#define TEST_NOLINT(...) TEST(__VA_ARGS__)
+/* NOLINTEND */
+
+/* NOLINTBEGIN */
+#define ASSERT_DEATH_IF_SUPPORTED_NOLINT(...) ASSERT_DEATH_IF_SUPPORTED(__VA_ARGS__)
+/* NOLINTEND */
+
+/* NOLINTBEGIN */
+#define TYPED_TEST_NOLINT(...) TYPED_TEST(__VA_ARGS__)
 /* NOLINTEND */
 
 namespace ppc::util {