test: drop a bunch of NOLINT

test/entt/meta/meta_dtor.cpp

@@ -9,19 +9,20 @@
 #include <entt/meta/resolve.hpp>
 
 struct clazz_t {
-    clazz_t() {
-        ++counter;
+    clazz_t(int &cnt)
+        : counter{&cnt} {
+        ++(*counter);
     }
 
-    static void destroy_decr(clazz_t &) {
-        --counter;
+    static void destroy_decr(clazz_t &instance) {
+        --(*instance.counter);
     }
 
     void destroy_incr() const {
-        ++counter;
+        ++(*counter);
     }
 
-    inline static int counter = 0; // NOLINT
+    int *counter;
 };
 
 struct MetaDtor: ::testing::Test {
@@ -30,9 +31,8 @@ struct MetaDtor: ::testing::Test {
 
         entt::meta<clazz_t>()
             .type("clazz"_hs)
+            .ctor<int &>()
             .dtor<clazz_t::destroy_decr>();
-
-        clazz_t::counter = 0;
     }
 
     void TearDown() override {
@@ -41,9 +41,9 @@ struct MetaDtor: ::testing::Test {
 };
 
 TEST_F(MetaDtor, Functionalities) {
-    ASSERT_EQ(clazz_t::counter, 0);
+    int counter{};
 
-    auto any = entt::resolve<clazz_t>().construct();
+    auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter));
     auto cref = std::as_const(any).as_ref();
     auto ref = any.as_ref();
 
@@ -51,7 +51,7 @@ TEST_F(MetaDtor, Functionalities) {
     ASSERT_TRUE(cref);
     ASSERT_TRUE(ref);
 
-    ASSERT_EQ(clazz_t::counter, 1);
+    ASSERT_EQ(counter, 1);
 
     cref.reset();
     ref.reset();
@@ -60,7 +60,7 @@ TEST_F(MetaDtor, Functionalities) {
     ASSERT_FALSE(cref);
     ASSERT_FALSE(ref);
 
-    ASSERT_EQ(clazz_t::counter, 1);
+    ASSERT_EQ(counter, 1);
 
     any.reset();
 
@@ -68,13 +68,13 @@ TEST_F(MetaDtor, Functionalities) {
     ASSERT_FALSE(cref);
     ASSERT_FALSE(ref);
 
-    ASSERT_EQ(clazz_t::counter, 0);
+    ASSERT_EQ(counter, 0);
 }
 
 TEST_F(MetaDtor, AsRefConstruction) {
-    ASSERT_EQ(clazz_t::counter, 0);
+    int counter{};
 
-    clazz_t instance{};
+    clazz_t instance{counter};
     auto any = entt::forward_as_meta(instance);
     auto cany = entt::forward_as_meta(std::as_const(instance));
     auto cref = cany.as_ref();
@@ -85,7 +85,7 @@ TEST_F(MetaDtor, AsRefConstruction) {
     ASSERT_TRUE(cref);
     ASSERT_TRUE(ref);
 
-    ASSERT_EQ(clazz_t::counter, 1);
+    ASSERT_EQ(counter, 1);
 
     any.reset();
     cany.reset();
@@ -97,18 +97,19 @@ TEST_F(MetaDtor, AsRefConstruction) {
     ASSERT_FALSE(cref);
     ASSERT_FALSE(ref);
 
-    ASSERT_EQ(clazz_t::counter, 1);
+    ASSERT_EQ(counter, 1);
 }
 
 TEST_F(MetaDtor, ReRegistration) {
     SetUp();
 
+    int counter{};
     auto &&node = entt::internal::resolve<clazz_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
 
     ASSERT_NE(node.dtor.dtor, nullptr);
 
     entt::meta<clazz_t>().dtor<&clazz_t::destroy_incr>();
-    entt::resolve<clazz_t>().construct().reset();
+    entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter)).reset();
 
-    ASSERT_EQ(clazz_t::counter, 2);
+    ASSERT_EQ(counter, 2);
 }

test/entt/meta/meta_func.cpp

@@ -53,7 +53,7 @@ struct func_t {
         return f(a, b);
     }
 
-    [[nodiscard]] int f(int a, int b) { // NOLINT
+    [[nodiscard]] int f(int a, const int b) {
         value = a;
         return b * b;
     }

test/entt/meta/meta_type.cpp

@@ -79,7 +79,7 @@ struct overloaded_func_t {
         return f(a, b);
     }
 
-    [[nodiscard]] int f(int a, int b) { // NOLINT
+    [[nodiscard]] int f(int a, const int b) {
         value = a;
         return g(b);
     }
@@ -92,7 +92,7 @@ struct overloaded_func_t {
         return g(v);
     }
 
-    [[nodiscard]] float f(int a, float b) { // NOLINT
+    [[nodiscard]] float f(int a, const float b) {
         value = a;
         return static_cast<float>(e(static_cast<int>(b)));
     }
@@ -122,7 +122,7 @@ struct MetaType: ::testing::Test {
         entt::meta<unsigned int>()
             .type("unsigned int"_hs)
             .data<0u>("min"_hs)
-            .data<100u>("max"_hs); // NOLINT
+            .data<128u>("max"_hs);
 
         entt::meta<base_t>()
             .type("base"_hs)
@@ -237,8 +237,10 @@ TEST_F(MetaType, Functionalities) {
 TEST_F(MetaType, SizeOf) {
     ASSERT_EQ(entt::resolve<void>().size_of(), 0u);
     ASSERT_EQ(entt::resolve<int>().size_of(), sizeof(int));
-    ASSERT_EQ(entt::resolve<int[]>().size_of(), 0u);              // NOLINT
-    ASSERT_EQ(entt::resolve<int[3]>().size_of(), sizeof(int[3])); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_EQ(entt::resolve<int[]>().size_of(), 0u);
+    ASSERT_EQ(entt::resolve<int[3]>().size_of(), sizeof(int[3]));
+    // NOLINTEND(*-avoid-c-arrays)
 }
 
 TEST_F(MetaType, Traits) {
@@ -254,8 +256,10 @@ TEST_F(MetaType, Traits) {
     ASSERT_FALSE(entt::resolve<unsigned int>().is_signed());
     ASSERT_FALSE(entt::resolve<clazz_t>().is_signed());
 
-    ASSERT_TRUE(entt::resolve<int[5]>().is_array());    // NOLINT
-    ASSERT_TRUE(entt::resolve<int[5][3]>().is_array()); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_TRUE(entt::resolve<int[5]>().is_array());
+    ASSERT_TRUE(entt::resolve<int[5][3]>().is_array());
+    // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(entt::resolve<int>().is_array());
 
     ASSERT_TRUE(entt::resolve<property_t>().is_enum());
@@ -442,36 +446,36 @@ TEST_F(MetaType, OverloadedFunc) {
     ASSERT_NE(res.try_cast<int>(), nullptr);
     ASSERT_EQ(res.cast<int>(), 16);
 
-    res = type.invoke("f"_hs, instance, 5); // NOLINT
+    res = type.invoke("f"_hs, instance, 2);
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 3);
     ASSERT_NE(res.try_cast<int>(), nullptr);
-    ASSERT_EQ(res.cast<int>(), 50);
+    ASSERT_EQ(res.cast<int>(), 8);
 
-    res = type.invoke("f"_hs, std::as_const(instance), 5); // NOLINT
+    res = type.invoke("f"_hs, std::as_const(instance), 2);
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 3);
     ASSERT_NE(res.try_cast<int>(), nullptr);
-    ASSERT_EQ(res.cast<int>(), 25);
+    ASSERT_EQ(res.cast<int>(), 4);
 
-    res = type.invoke("f"_hs, instance, 6, 7.f); // NOLINT
+    res = type.invoke("f"_hs, instance, 0, 1.f);
 
     ASSERT_TRUE(res);
-    ASSERT_EQ(instance.value, 6);
+    ASSERT_EQ(instance.value, 0);
     ASSERT_NE(res.try_cast<float>(), nullptr);
-    ASSERT_EQ(res.cast<float>(), 14.f);
+    ASSERT_EQ(res.cast<float>(), 2.f);
 
-    res = type.invoke("f"_hs, instance, 8, 9.f);
+    res = type.invoke("f"_hs, instance, 4, 8.f);
 
     ASSERT_TRUE(res);
-    ASSERT_EQ(instance.value, 8);
+    ASSERT_EQ(instance.value, 4);
     ASSERT_NE(res.try_cast<float>(), nullptr);
-    ASSERT_EQ(res.cast<float>(), 18.f);
+    ASSERT_EQ(res.cast<float>(), 16.f);
 
     // it fails as an ambiguous call
-    ASSERT_FALSE(type.invoke("f"_hs, instance, 8, 9.));
+    ASSERT_FALSE(type.invoke("f"_hs, instance, 4, 8.));
 }
 
 TEST_F(MetaType, Construct) {
@@ -645,11 +649,11 @@ TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
     ASSERT_EQ(type.data("min"_hs).type(), type);
     ASSERT_EQ(type.data("max"_hs).type(), type);
 
-    ASSERT_FALSE(type.data("min"_hs).set({}, 100u));
+    ASSERT_FALSE(type.data("min"_hs).set({}, 128u));
     ASSERT_FALSE(type.data("max"_hs).set({}, 0u));
 
     ASSERT_EQ(type.data("min"_hs).get({}).cast<unsigned int>(), 0u);
-    ASSERT_EQ(type.data("max"_hs).get({}).cast<unsigned int>(), 100u);
+    ASSERT_EQ(type.data("max"_hs).get({}).cast<unsigned int>(), 128u);
 }
 
 TEST_F(MetaType, Variables) {