test: drop a bunch of NOLINT

test/entt/meta/meta_any.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <iterator>
 #include <memory>
@@ -60,10 +61,10 @@ struct fat_t: empty_t {
     fat_t &operator=(const fat_t &) = default;
 
     bool operator==(const fat_t &other) const {
-        return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
+        return (value == other.value);
     }
 
-    double value[4]; // NOLINT
+    std::array<double, 4u> value{};
 };
 
 enum class enum_class : unsigned short int {

test/entt/meta/meta_data.cpp

@@ -82,8 +82,8 @@ struct multi_setter_t {
 };
 
 struct array_t {
-    inline static int global[3]; // NOLINT
-    int local[5];                // NOLINT
+    inline static int global[2]; // NOLINT
+    int local[4];                // NOLINT
 };
 
 enum class property_t : entt::id_type {
@@ -526,8 +526,10 @@ TEST_F(MetaData, ArrayStatic) {
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
-    ASSERT_EQ(data.type(), entt::resolve<int[3]>());  // NOLINT
-    ASSERT_EQ(data.arg(0u), entt::resolve<int[3]>()); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_EQ(data.type(), entt::resolve<int[2]>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[2]>());
+    // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_TRUE(data.type().is_array());
@@ -542,8 +544,10 @@ TEST_F(MetaData, Array) {
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
-    ASSERT_EQ(data.type(), entt::resolve<int[5]>());  // NOLINT
-    ASSERT_EQ(data.arg(0u), entt::resolve<int[5]>()); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_EQ(data.type(), entt::resolve<int[4]>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[4]>());
+    // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_TRUE(data.type().is_array());

test/entt/meta/meta_pointer.cpp

@@ -428,11 +428,15 @@ TEST(MetaPointerLike, DereferenceProxyPointer) {
 }
 
 TEST(MetaPointerLike, DereferenceArray) {
-    const entt::meta_any array{std::in_place_type<int[3]>};             // NOLINT
-    const entt::meta_any array_of_array{std::in_place_type<int[3][3]>}; // NOLINT
-
-    ASSERT_EQ(array.type(), entt::resolve<int[3]>());             // NOLINT
-    ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>()); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    const entt::meta_any array{std::in_place_type<int[3]>};
+    const entt::meta_any array_of_array{std::in_place_type<int[3][3]>};
+    // NOLINTEND(*-avoid-c-arrays)
+
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_EQ(array.type(), entt::resolve<int[3]>());
+    ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>());
+    // NOLINTEND(*-avoid-c-arrays)
 
     ASSERT_FALSE(*array);
     ASSERT_FALSE(*array_of_array);

test/entt/meta/meta_utility.cpp

@@ -1,4 +1,5 @@
 #include <array>
+#include <iterator>
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/core/type_traits.hpp>
@@ -188,15 +189,15 @@ TEST_F(MetaUtility, MetaGetter) {
 }
 
 TEST_F(MetaUtility, MetaInvokeWithCandidate) {
-    entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
+    std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
     args[0u].cast<clazz &>().value = 3;
 
-    ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, nullptr)));
+    ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, std::next(args.data()))));
     ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::getter, nullptr)));
 
-    ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args + 1u))); // NOLINT
-    ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args)));     // NOLINT
-    ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 42);
+    ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, std::next(args.data()))));
+    ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args.data())));
+    ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 4);
     ASSERT_FALSE((entt::meta_invoke<clazz>(args[1u], &clazz::getter, nullptr)));
 
     ASSERT_EQ((entt::meta_invoke<clazz>({}, &clazz::get_value, nullptr)).cast<int>(), 3);
@@ -206,20 +207,20 @@ TEST_F(MetaUtility, MetaInvokeWithCandidate) {
     const auto setter = [](int &value) { value = 3; };
     const auto getter = [](int value) { return value * 2; };
 
-    ASSERT_TRUE(entt::meta_invoke<test::empty>({}, setter, args + 1u));              // NOLINT
-    ASSERT_EQ(entt::meta_invoke<test::empty>({}, getter, args + 1u).cast<int>(), 6); // NOLINT
+    ASSERT_TRUE(entt::meta_invoke<test::empty>({}, setter, std::next(args.data())));
+    ASSERT_EQ(entt::meta_invoke<test::empty>({}, getter, std::next(args.data())).cast<int>(), 6);
 }
 
 TEST_F(MetaUtility, MetaInvoke) {
-    entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
+    std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
     args[0u].cast<clazz &>().value = 3;
 
-    ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, nullptr)));
+    ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, std::next(args.data()))));
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>({}, nullptr)));
 
-    ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args + 1u))); // NOLINT
-    ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args)));     // NOLINT
-    ASSERT_EQ((entt::meta_invoke<clazz, &clazz::getter>(args[0u], nullptr)).cast<int>(), 42);
+    ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], std::next(args.data()))));
+    ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args.data())));
+    ASSERT_EQ((entt::meta_invoke<clazz, &clazz::getter>(args[0u], nullptr)).cast<int>(), 4);
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>(args[1u], nullptr)));
 
     ASSERT_EQ((entt::meta_invoke<clazz, &clazz::get_value>({}, nullptr)).cast<int>(), 3);
@@ -228,42 +229,42 @@ TEST_F(MetaUtility, MetaInvoke) {
 }
 
 TEST_F(MetaUtility, MetaConstructArgsOnly) {
-    entt::meta_any args[2u]{clazz{}, 42};                         // NOLINT
-    const auto any = entt::meta_construct<clazz, int>(args + 1u); // NOLINT
+    std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
+    const auto any = entt::meta_construct<clazz, int>(std::next(args.data()));
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct<clazz, int>(args))); // NOLINT
-    ASSERT_EQ(any.cast<const clazz &>().member, 42);
+    ASSERT_FALSE((entt::meta_construct<clazz, int>(args.data())));
+    ASSERT_EQ(any.cast<const clazz &>().member, 4);
 }
 
 TEST_F(MetaUtility, MetaConstructWithCandidate) {
-    entt::meta_any args[2u]{clazz{}, 42};                                     // NOLINT
-    const auto any = entt::meta_construct<clazz>(&clazz::factory, args + 1u); // NOLINT
+    std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
+    const auto any = entt::meta_construct<clazz>(&clazz::factory, std::next(args.data()));
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args))); // NOLINT
-    ASSERT_EQ(any.cast<const clazz &>().member, 42);
+    ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args.data())));
+    ASSERT_EQ(any.cast<const clazz &>().member, 4);
 
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
-    ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args))); // NOLINT
-    ASSERT_EQ(args[0u].cast<const clazz &>().member, 42);
+    ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args.data())));
+    ASSERT_EQ(args[0u].cast<const clazz &>().member, 4);
 
     const auto setter = [](int &value) { value = 3; };
     const auto builder = [](int value) { return value * 2; };
 
-    ASSERT_TRUE(entt::meta_construct<test::empty>(setter, args + 1u));               // NOLINT
-    ASSERT_EQ(entt::meta_construct<test::empty>(builder, args + 1u).cast<int>(), 6); // NOLINT
+    ASSERT_TRUE(entt::meta_construct<test::empty>(setter, std::next(args.data())));
+    ASSERT_EQ(entt::meta_construct<test::empty>(builder, std::next(args.data())).cast<int>(), 6);
 }
 
 TEST_F(MetaUtility, MetaConstruct) {
-    std::array args{entt::meta_any{clazz{}}, entt::meta_any{2}};
-    const auto any = entt::meta_construct<clazz, &clazz::factory>(args.data() + 1u); // NOLINT
+    std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
+    const auto any = entt::meta_construct<clazz, &clazz::factory>(std::next(args.data()));
 
     ASSERT_TRUE(any);
     ASSERT_FALSE((entt::meta_construct<clazz, &clazz::factory>(args.data())));
-    ASSERT_EQ(any.cast<const clazz &>().member, 2);
+    ASSERT_EQ(any.cast<const clazz &>().member, 4);
 
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
     ASSERT_TRUE((entt::meta_construct<clazz, &clazz::static_setter>(args.data())));
-    ASSERT_EQ(args[0u].cast<const clazz &>().member, 2);
+    ASSERT_EQ(args[0u].cast<const clazz &>().member, 4);
 }