Remove NOLINTs (#457)

Author: aobolensk

.clang-tidy

@@ -26,6 +26,7 @@ Checks: >
   -modernize-avoid-c-arrays,
   -modernize-loop-convert,
   -modernize-use-trailing-return-type,
+  -portability-template-virtual-member-function,
   -readability-magic-numbers
 
 WarningsAsErrors: "*"
@@ -81,7 +82,7 @@ CheckOptions:
     value:           1
   # Functions with scores beyond 15 are typically flagged as potentially problematic (empirically)
   - key:             readability-function-cognitive-complexity.Threshold
-    value:           20  # default: 25
+    value:           15  # default: 25
   - key:             readability-identifier-length.MinimumVariableNameLength
     value:           1
   - key:             readability-identifier-length.MinimumParameterNameLength

.github/workflows/static-analysis-pr.yml

@@ -29,8 +29,8 @@ jobs:
             cmake -S . -B build -G Ninja
             -D CMAKE_C_COMPILER_LAUNCHER=ccache -D CMAKE_CXX_COMPILER_LAUNCHER=ccache
             -D CMAKE_BUILD_TYPE=RELEASE -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-          config_file: .clang-tidy
           exclude: 3rdparty
+          clang_tidy_checks: ""
           split_workflow: true
           clang_tidy_version: "19"
           lgtm_comment_body: ""
@@ -62,8 +62,8 @@ jobs:
             cmake -S . -B build -G Ninja
             -D CMAKE_C_COMPILER_LAUNCHER=ccache -D CMAKE_CXX_COMPILER_LAUNCHER=ccache
             -D CMAKE_BUILD_TYPE=RELEASE -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-          config_file: .clang-tidy
           exclude: 3rdparty
+          clang_tidy_checks: ""
           split_workflow: true
           clang_tidy_version: "19"
           lgtm_comment_body: ""

modules/core/performance/tests/.clang-tidy

@@ -0,0 +1,41 @@
+InheritParentConfig: true
+
+Checks: >
+  bugprone-*,
+  clang-diagnostic-*,
+  concurrency-*,
+  cppcoreguidelines-*,
+  llvm-include-order,
+  llvm-namespace-comment,
+  misc-*,
+  modernize-*,
+  mpi-*,
+  openmp-*,
+  performance-*,
+  portability-*,
+  readability-*,
+  -bugprone-casting-through-void,
+  -bugprone-easily-swappable-parameters,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-special-member-functions,
+  -misc-const-correctness,
+  -misc-non-private-member-variables-in-classes,
+  -modernize-avoid-c-arrays,
+  -modernize-loop-convert,
+  -modernize-use-trailing-return-type,
+  -portability-template-virtual-member-function,
+  -readability-magic-numbers,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -misc-use-anonymous-namespace,
+  -modernize-use-std-print,
+  -modernize-type-traits,
+
+CheckOptions:
+  - key:             readability-function-cognitive-complexity.Threshold
+    value:           50  # default: 25

modules/core/performance/tests/perf_tests.cpp

@@ -63,7 +63,7 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) {
   };
   perf_analyzer.PipelineRun(perf_attr);
 
-  ASSERT_ANY_THROW_NOLINT(perf_analyzer.PrintPerfStatistic("check_perf_pipeline_uint8_t_slow_test"));
+  ASSERT_ANY_THROW(perf_analyzer.PrintPerfStatistic("check_perf_pipeline_uint8_t_slow_test"));
 }
 
 TEST(perf_tests, check_perf_task_exception) {
@@ -73,7 +73,7 @@ TEST(perf_tests, check_perf_task_exception) {
 
   ppc::core::Perf<std::vector<uint32_t>, uint32_t> perf_analyzer(test_task);
 
-  ASSERT_ANY_THROW_NOLINT(perf_analyzer.PrintPerfStatistic("check_perf_task_exception"));
+  ASSERT_ANY_THROW(perf_analyzer.PrintPerfStatistic("check_perf_task_exception"));
 
   ppc::core::PerfAttr perf_attr;
   perf_analyzer.TaskRun(perf_attr);
@@ -109,12 +109,13 @@ TEST_P(GetStringParamNameParamTest, ReturnsExpectedString) {
   EXPECT_EQ(ppc::core::GetStringParamName(param.input), param.expected_output);
 }
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(
-    ParamTests, GetStringParamNameParamTest,
-    ::testing::Values(ParamTestCase{ppc::core::PerfResults::kTaskRun, "task_run"},
-                      ParamTestCase{ppc::core::PerfResults::kPipeline, "pipeline"},
-                      ParamTestCase{ppc::core::PerfResults::TypeOfRunning::kNone, "none"}),
-    [](const ::testing::TestParamInfo<ParamTestCase>& info) { return info.param.expected_output; });
+INSTANTIATE_TEST_SUITE_P(ParamTests, GetStringParamNameParamTest,
+                         ::testing::Values(ParamTestCase{ppc::core::PerfResults::kTaskRun, "task_run"},
+                                           ParamTestCase{ppc::core::PerfResults::kPipeline, "pipeline"},
+                                           ParamTestCase{ppc::core::PerfResults::TypeOfRunning::kNone, "none"}),
+                         [](const ::testing::TestParamInfo<ParamTestCase>& info) {
+                           return info.param.expected_output;
+                         });
 
 struct TaskTypeTestCase {
   ppc::core::TypeOfTask type;
@@ -151,22 +152,22 @@ TEST_P(GetStringTaskTypeTest, ReturnsExpectedString) {
   EXPECT_EQ(GetStringTaskType(param.type, temp_path), param.expected) << "Failed on: " << param.label;
 }
 
-INSTANTIATE_TEST_SUITE_P_NOLINT(AllTypeCases, GetStringTaskTypeTest,
-                                ::testing::Values(TaskTypeTestCase{ppc::core::TypeOfTask::kALL, "all_ALL", "kALL"},
-                                                  TaskTypeTestCase{ppc::core::TypeOfTask::kSTL, "stl_STL", "kSTL"},
-                                                  TaskTypeTestCase{ppc::core::TypeOfTask::kOMP, "omp_OMP", "kOMP"},
-                                                  TaskTypeTestCase{ppc::core::TypeOfTask::kMPI, "mpi_MPI", "kMPI"},
-                                                  TaskTypeTestCase{ppc::core::TypeOfTask::kTBB, "tbb_TBB", "kTBB"},
-                                                  TaskTypeTestCase{ppc::core::TypeOfTask::kSEQ, "seq_SEQ", "kSEQ"}));
+INSTANTIATE_TEST_SUITE_P(AllTypeCases, GetStringTaskTypeTest,
+                         ::testing::Values(TaskTypeTestCase{ppc::core::TypeOfTask::kALL, "all_ALL", "kALL"},
+                                           TaskTypeTestCase{ppc::core::TypeOfTask::kSTL, "stl_STL", "kSTL"},
+                                           TaskTypeTestCase{ppc::core::TypeOfTask::kOMP, "omp_OMP", "kOMP"},
+                                           TaskTypeTestCase{ppc::core::TypeOfTask::kMPI, "mpi_MPI", "kMPI"},
+                                           TaskTypeTestCase{ppc::core::TypeOfTask::kTBB, "tbb_TBB", "kTBB"},
+                                           TaskTypeTestCase{ppc::core::TypeOfTask::kSEQ, "seq_SEQ", "kSEQ"}));
 
-TEST_NOLINT(GetStringTaskTypeStandaloneTest, ThrowsIfFileMissing) {
+TEST(GetStringTaskTypeStandaloneTest, ThrowsIfFileMissing) {
   std::string missing_path = "non_existent_settings.json";
-  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, missing_path), std::runtime_error);
+  EXPECT_THROW(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, missing_path), std::runtime_error);
 }
 
-TEST_NOLINT(GetStringTaskTypeStandaloneTest, ExceptionMessageContainsPath) {
+TEST(GetStringTaskTypeStandaloneTest, ExceptionMessageContainsPath) {
   const std::string missing_path = "non_existent_settings.json";
-  EXPECT_THROW_NOLINT(
+  EXPECT_THROW(
       try { GetStringTaskType(ppc::core::TypeOfTask::kSEQ, missing_path); } catch (const std::runtime_error& e) {
         EXPECT_NE(std::string(e.what()).find(missing_path), std::string::npos);
         throw;
@@ -184,23 +185,22 @@ TEST(GetStringTaskTypeStandaloneTest, ReturnsUnknownForInvalidEnum) {
   std::filesystem::remove(path);
 }
 
-TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfFileCannotBeOpened) {
-  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, "definitely_missing_file.json"),
-                      std::runtime_error);
+TEST(GetStringTaskTypeEdgeCases, ThrowsIfFileCannotBeOpened) {
+  EXPECT_THROW(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, "definitely_missing_file.json"), std::runtime_error);
 }
 
-TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfJsonIsMalformed) {
+TEST(GetStringTaskTypeEdgeCases, ThrowsIfJsonIsMalformed) {
   std::string path = (std::filesystem::temp_directory_path() / "bad_json.json").string();
   std::ofstream(path) << "{ this is not valid json ";
-  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), NlohmannJsonParseError);
+  EXPECT_THROW(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), NlohmannJsonParseError);
   std::filesystem::remove(path);
 }
 
-TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfJsonValueIsNull) {
+TEST(GetStringTaskTypeEdgeCases, ThrowsIfJsonValueIsNull) {
   std::string path = (std::filesystem::temp_directory_path() / "null_value.json").string();
   std::ofstream(path) << R"({"tasks": { "seq": null }})";
 
-  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), NlohmannJsonTypeError);
+  EXPECT_THROW(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, path), NlohmannJsonTypeError);
 
   std::filesystem::remove(path);
 }
@@ -237,9 +237,9 @@ TEST(TaskTest, GetDynamicTypeReturnsCorrectEnum) {
   EXPECT_EQ(task.GetDynamicTypeOfTask(), ppc::core::TypeOfTask::kOMP);
 }
 
-TEST_NOLINT(TaskTest, DestructorTerminatesIfWrongOrder) {
+TEST(TaskTest, DestructorTerminatesIfWrongOrder) {
   testing::FLAGS_gtest_death_test_style = "threadsafe";
-  ASSERT_DEATH_IF_SUPPORTED_NOLINT(
+  ASSERT_DEATH_IF_SUPPORTED(
       {
         DummyTask task;
         task.Run();
@@ -262,7 +262,7 @@ using TestTypes = ::testing::Types<my::nested::Type, my::Another, int>;
 
 TYPED_TEST_SUITE(GetNamespaceTest, TestTypes);
 
-TYPED_TEST_NOLINT(GetNamespaceTest, ExtractsNamespaceCorrectly) {
+TYPED_TEST(GetNamespaceTest, ExtractsNamespaceCorrectly) {
   constexpr std::string_view kNs = ppc::util::GetNamespace<TypeParam>();
 
   if constexpr (std::is_same_v<TypeParam, my::nested::Type>) {

modules/core/runners/src/runners.cpp

@@ -2,9 +2,7 @@
 
 #include <gtest/gtest.h>
 #include <mpi.h>
-#include <omp.h>
 
-#include <cstdio>
 #include <cstdlib>
 #include <format>
 #include <iostream>

modules/core/task/include/task.hpp

@@ -14,6 +14,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 namespace ppc::core {
 

modules/core/task/tests/.clang-tidy

@@ -0,0 +1,41 @@
+InheritParentConfig: true
+
+Checks: >
+  bugprone-*,
+  clang-diagnostic-*,
+  concurrency-*,
+  cppcoreguidelines-*,
+  llvm-include-order,
+  llvm-namespace-comment,
+  misc-*,
+  modernize-*,
+  mpi-*,
+  openmp-*,
+  performance-*,
+  portability-*,
+  readability-*,
+  -bugprone-casting-through-void,
+  -bugprone-easily-swappable-parameters,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-special-member-functions,
+  -misc-const-correctness,
+  -misc-non-private-member-variables-in-classes,
+  -modernize-avoid-c-arrays,
+  -modernize-loop-convert,
+  -modernize-use-trailing-return-type,
+  -portability-template-virtual-member-function,
+  -readability-magic-numbers,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -misc-use-anonymous-namespace,
+  -modernize-use-std-print,
+  -modernize-type-traits,
+
+CheckOptions:
+  - key:             readability-function-cognitive-complexity.Threshold
+    value:           50  # default: 25

modules/core/task/tests/task_tests.cpp

@@ -5,7 +5,6 @@
 #include <vector>
 
 #include "core/task/tests/test_task.hpp"
-#include "core/util/include/util.hpp"
 
 TEST(task_tests, check_int32_t) {
   // Create data
@@ -128,7 +127,7 @@ TEST(task_tests, check_float) {
   EXPECT_NEAR(test_task.GetOutput(), in.size(), 1e-3);
 }
 
-TEST_NOLINT(task_tests, check_wrong_order_disabled_valgrind) {
+TEST(task_tests, check_wrong_order_disabled_valgrind) {
   auto destroy_function = [] {
     // Create data
     std::vector<float> in(20, 1);
@@ -143,7 +142,7 @@ TEST_NOLINT(task_tests, check_wrong_order_disabled_valgrind) {
   EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*");
 }
 
-TEST_NOLINT(task_tests, check_empty_order_disabled_valgrind) {
+TEST(task_tests, check_empty_order_disabled_valgrind) {
   auto destroy_function = [] {
     // Create data
     std::vector<float> in(20, 1);

modules/core/task/tests/test_task.hpp

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

modules/core/util/include/func_test_util.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <gtest/gtest.h>
-#include <omp.h>
 #include <tbb/tick_count.h>
 
 #include <concepts>