Remove NOLINTs

aobolensk · aobolensk · commit cf4e310892bf · 2025-06-21T14:59:35.000+02:00
diff --git a/.clang-tidy b/.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
diff --git a/modules/core/performance/tests/.clang-tidy b/modules/core/performance/tests/.clang-tidy
@@ -0,0 +1,12 @@
+InheritParentConfig: true
+
+Checks: >
+  -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
diff --git a/modules/core/performance/tests/perf_tests.cpp b/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,7 +109,7 @@ TEST_P(GetStringParamNameParamTest, ReturnsExpectedString) {
   EXPECT_EQ(ppc::core::GetStringParamName(param.input), param.expected_output);
 }
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(
+INSTANTIATE_TEST_SUITE_P(
     ParamTests, GetStringParamNameParamTest,
     ::testing::Values(ParamTestCase{ppc::core::PerfResults::kTaskRun, "task_run"},
                       ParamTestCase{ppc::core::PerfResults::kPipeline, "pipeline"},
@@ -151,22 +151,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,
+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 +184,23 @@ TEST(GetStringTaskTypeStandaloneTest, ReturnsUnknownForInvalidEnum) {
   std::filesystem::remove(path);
 }
 
-TEST_NOLINT(GetStringTaskTypeEdgeCases, ThrowsIfFileCannotBeOpened) {
-  EXPECT_THROW_NOLINT(GetStringTaskType(ppc::core::TypeOfTask::kSEQ, "definitely_missing_file.json"),
+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>) {
diff --git a/modules/core/runners/src/runners.cpp b/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>
diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp
@@ -14,6 +14,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 namespace ppc::core {
 
diff --git a/modules/core/task/tests/.clang-tidy b/modules/core/task/tests/.clang-tidy
@@ -0,0 +1,12 @@
+InheritParentConfig: true
+
+Checks: >
+  -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
diff --git a/modules/core/task/tests/task_tests.cpp b/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);
diff --git a/modules/core/task/tests/test_task.hpp b/modules/core/task/tests/test_task.hpp
@@ -2,7 +2,6 @@
 
 #include <chrono>
 #include <thread>
-#include <vector>
 
 #include "core/task/include/task.hpp"
 
diff --git a/modules/core/util/include/func_test_util.hpp b/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>
diff --git a/modules/core/util/include/perf_test_util.hpp b/modules/core/util/include/perf_test_util.hpp
@@ -115,8 +115,8 @@ auto MakePerfTaskTuples(const std::string& settings_path) {
 }
 
 template <typename Tuple, std::size_t... I>
-auto TupleToGTestValuesImpl(Tuple&& tup, std::index_sequence<I...> /*unused*/) {
-  return ::testing::Values(std::get<I>(std::forward<Tuple>(tup))...);
+auto TupleToGTestValuesImpl(const Tuple& tup, std::index_sequence<I...> /*unused*/) {
+  return ::testing::Values(std::get<I>(tup)...);
 }
 
 template <typename Tuple>
diff --git a/modules/core/util/include/util.hpp b/modules/core/util/include/util.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "nlohmann/json_fwd.hpp"
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
@@ -11,24 +12,16 @@
 #pragma warning(disable : 4459)
 #endif
 
-#include <nlohmann/json.hpp>  // NOLINT(misc-include-cleaner)
+#include <nlohmann/json.hpp>
 
 /// @brief JSON namespace used for settings and config parsing.
-using NlohmannJsonParseError = nlohmann::json::parse_error;  // NOLINT(misc-include-cleaner)
+using NlohmannJsonParseError = nlohmann::json::parse_error;
 /// @brief JSON namespace used for settings and config typing.
-using NlohmannJsonTypeError = nlohmann::json::type_error;  // NOLINT(misc-include-cleaner)
+using NlohmannJsonTypeError = nlohmann::json::type_error;
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-#define ASSERT_ANY_THROW_NOLINT(stmt) ASSERT_ANY_THROW(stmt)                                   // NOLINT
-#define EXPECT_THROW_NOLINT(stmt, error) EXPECT_THROW(stmt, error)                             // NOLINT
-#define TEST_NOLINT(test_suite_name, test_name) TEST(test_suite_name, test_name)               // NOLINT
-#define ASSERT_DEATH_IF_SUPPORTED_NOLINT(stmt, name) ASSERT_DEATH_IF_SUPPORTED(stmt, name)     // NOLINT
-#define TYPED_TEST_NOLINT(test_suite_name, test_name) TYPED_TEST(test_suite_name, test_name)   // NOLINT
-#define INSTANTIATE_TEST_SUITE_P_WITH_NAME(n, t, g, ng) INSTANTIATE_TEST_SUITE_P(n, t, g, ng)  // NOLINT
-#define INSTANTIATE_TEST_SUITE_P_NOLINT(n, t, g) INSTANTIATE_TEST_SUITE_P(n, t, g)             // NOLINT
-// INSTANTIATE_TEST_SUITE_P | n, t, g, ng == name, test_case_name, generator, name_generator
 
 namespace ppc::util {
 
@@ -95,7 +88,6 @@ constexpr std::string_view GetNamespace() {
 #endif
 }
 
-// NOLINTNEXTLINE(misc-include-cleaner)
 inline std::shared_ptr<nlohmann::json> InitJSONPtr() { return std::make_shared<nlohmann::json>(); }
 
 bool IsUnderMpirun();
diff --git a/tasks/example_processes/mpi/src/ops_mpi.cpp b/tasks/example_processes/mpi/src/ops_mpi.cpp
@@ -2,7 +2,6 @@
 
 #include <mpi.h>
 
-#include <cmath>
 #include <numeric>
 #include <vector>
 
diff --git a/tasks/example_processes/seq/src/ops_seq.cpp b/tasks/example_processes/seq/src/ops_seq.cpp
@@ -1,6 +1,5 @@
 #include "example_processes/seq/include/ops_seq.hpp"
 
-#include <cmath>
 #include <numeric>
 #include <vector>
 
diff --git a/tasks/example_processes/tests/.clang-tidy b/tasks/example_processes/tests/.clang-tidy
@@ -0,0 +1,12 @@
+InheritParentConfig: true
+
+Checks: >
+  -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:           25  # default: 25
diff --git a/tasks/example_processes/tests/functional/main.cpp b/tasks/example_processes/tests/functional/main.cpp
@@ -72,7 +72,7 @@ const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 
 const auto kPerfTestName = NesterovARunFuncTestsProcesses::PrintFuncTestName<NesterovARunFuncTestsProcesses>;
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(PicMatrixTests, NesterovARunFuncTestsProcesses, kGtestValues, kPerfTestName);
+INSTANTIATE_TEST_SUITE_P(PicMatrixTests, NesterovARunFuncTestsProcesses, kGtestValues, kPerfTestName);
 
 }  // namespace
 
diff --git a/tasks/example_processes/tests/performance/main.cpp b/tasks/example_processes/tests/performance/main.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include "core/util/include/perf_test_util.hpp"
-#include "core/util/include/util.hpp"
 #include "example_processes/common/include/common.hpp"
 #include "example_processes/mpi/include/ops_mpi.hpp"
 #include "example_processes/seq/include/ops_seq.hpp"
@@ -28,6 +27,6 @@ const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
 
 const auto kPerfTestName = ExampleRunPerfTestProcesses::CustomPerfTestName;
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(RunModeTests, ExampleRunPerfTestProcesses, kGtestValues, kPerfTestName);
+INSTANTIATE_TEST_SUITE_P(RunModeTests, ExampleRunPerfTestProcesses, kGtestValues, kPerfTestName);
 
 }  // namespace nesterov_a_test_task_processes
diff --git a/tasks/example_threads/all/src/ops_all.cpp b/tasks/example_threads/all/src/ops_all.cpp
@@ -3,7 +3,6 @@
 #include <mpi.h>
 
 #include <atomic>
-#include <cmath>
 #include <numeric>
 #include <thread>
 #include <vector>
diff --git a/tasks/example_threads/omp/src/ops_omp.cpp b/tasks/example_threads/omp/src/ops_omp.cpp
@@ -1,7 +1,6 @@
 #include "example_threads/omp/include/ops_omp.hpp"
 
 #include <atomic>
-#include <cmath>
 #include <numeric>
 #include <vector>
 
diff --git a/tasks/example_threads/seq/src/ops_seq.cpp b/tasks/example_threads/seq/src/ops_seq.cpp
@@ -1,6 +1,5 @@
 #include "example_threads/seq/include/ops_seq.hpp"
 
-#include <cmath>
 #include <numeric>
 #include <vector>
 
diff --git a/tasks/example_threads/stl/src/ops_stl.cpp b/tasks/example_threads/stl/src/ops_stl.cpp
@@ -1,7 +1,6 @@
 #include "example_threads/stl/include/ops_stl.hpp"
 
 #include <atomic>
-#include <cmath>
 #include <numeric>
 #include <thread>
 #include <vector>
diff --git a/tasks/example_threads/tbb/src/ops_tbb.cpp b/tasks/example_threads/tbb/src/ops_tbb.cpp
@@ -3,7 +3,6 @@
 #include <tbb/tbb.h>
 
 #include <atomic>
-#include <cmath>
 #include <core/util/include/util.hpp>
 #include <numeric>
 #include <vector>
diff --git a/tasks/example_threads/tests/.clang-tidy b/tasks/example_threads/tests/.clang-tidy
@@ -0,0 +1,12 @@
+InheritParentConfig: true
+
+Checks: >
+  -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:           25  # default: 25
diff --git a/tasks/example_threads/tests/functional/main.cpp b/tasks/example_threads/tests/functional/main.cpp
@@ -78,7 +78,7 @@ const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 
 const auto kPerfTestName = NesterovARunFuncTestsThreads::PrintFuncTestName<NesterovARunFuncTestsThreads>;
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(PicMatrixTests, NesterovARunFuncTestsThreads, kGtestValues, kPerfTestName);
+INSTANTIATE_TEST_SUITE_P(PicMatrixTests, NesterovARunFuncTestsThreads, kGtestValues, kPerfTestName);
 
 }  // namespace
 
diff --git a/tasks/example_threads/tests/performance/main.cpp b/tasks/example_threads/tests/performance/main.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include "core/util/include/perf_test_util.hpp"
-#include "core/util/include/util.hpp"
 #include "example_threads/all/include/ops_all.hpp"
 #include "example_threads/common/include/common.hpp"
 #include "example_threads/omp/include/ops_omp.hpp"
@@ -32,6 +31,6 @@ const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
 
 const auto kPerfTestName = ExampleRunPerfTestThreads::CustomPerfTestName;
 
-INSTANTIATE_TEST_SUITE_P_WITH_NAME(RunModeTests, ExampleRunPerfTestThreads, kGtestValues, kPerfTestName);
+INSTANTIATE_TEST_SUITE_P(RunModeTests, ExampleRunPerfTestThreads, kGtestValues, kPerfTestName);
 
 }  // namespace nesterov_a_test_task_threads

Original file line number	Diff line number	Diff line change
`@@ -115,8 +115,8 @@ auto MakePerfTaskTuples(const std::string& settings_path) {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`template <typename Tuple, std::size_t... I>`
`118`		`-auto TupleToGTestValuesImpl(Tuple&& tup, std::index_sequence<I...> /unused/) {`
`119`		`- return ::testing::Values(std::get<I>(std::forward<Tuple>(tup))...);`
	`118`	`+auto TupleToGTestValuesImpl(const Tuple& tup, std::index_sequence<I...> /unused/) {`
	`119`	`+ return ::testing::Values(std::get<I>(tup)...);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`template <typename Tuple>`