test: refine linter directives

test/entt/core/any.cpp

@@ -62,7 +62,7 @@ TEST_F(Any, SBO) {
     entt::any any{'c'};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
     ASSERT_EQ(any.type(), entt::type_id<char>());
     ASSERT_EQ(entt::any_cast<double>(&any), nullptr);
@@ -74,7 +74,7 @@ TEST_F(Any, NoSBO) {
     entt::any any{instance};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
     ASSERT_EQ(any.type(), entt::type_id<fat>());
     ASSERT_EQ(entt::any_cast<double>(&any), nullptr);
@@ -85,7 +85,7 @@ TEST_F(Any, Empty) {
     entt::any any{};
 
     ASSERT_FALSE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
     ASSERT_EQ(any.type(), entt::type_id<void>());
     ASSERT_EQ(entt::any_cast<double>(&any), nullptr);
@@ -96,7 +96,7 @@ TEST_F(Any, SBOInPlaceTypeConstruction) {
     entt::any any{std::in_place_type<int>, 42};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
     ASSERT_EQ(any.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<double>(&any), nullptr);
@@ -105,7 +105,7 @@ TEST_F(Any, SBOInPlaceTypeConstruction) {
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
-    ASSERT_FALSE(other.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(other.owner()); // NOLINT
     ASSERT_EQ(other.policy(), entt::any_policy::ref);
     ASSERT_EQ(other.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<int>(other), 42);
@@ -117,7 +117,7 @@ TEST_F(Any, SBOAsRefConstruction) {
     entt::any any{entt::forward_as_any(value)};
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::ref);
     ASSERT_EQ(any.type(), entt::type_id<int>());
 
@@ -136,7 +136,7 @@ TEST_F(Any, SBOAsRefConstruction) {
     any.emplace<int &>(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::ref);
     ASSERT_EQ(any.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<int>(&any), &value);
@@ -144,7 +144,7 @@ TEST_F(Any, SBOAsRefConstruction) {
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
-    ASSERT_FALSE(other.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(other.owner()); // NOLINT
     ASSERT_EQ(other.policy(), entt::any_policy::ref);
     ASSERT_EQ(other.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<int>(other), 42);
@@ -156,7 +156,7 @@ TEST_F(Any, SBOAsConstRefConstruction) {
     entt::any any{entt::forward_as_any(value)};
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::cref);
     ASSERT_EQ(any.type(), entt::type_id<int>());
 
@@ -175,7 +175,7 @@ TEST_F(Any, SBOAsConstRefConstruction) {
     any.emplace<const int &>(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::any_policy::cref);
     ASSERT_EQ(any.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<const int>(&any), &value);
@@ -183,7 +183,7 @@ TEST_F(Any, SBOAsConstRefConstruction) {
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
-    ASSERT_FALSE(other.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(other.owner()); // NOLINT
     ASSERT_EQ(other.policy(), entt::any_policy::cref);
     ASSERT_EQ(other.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<int>(other), 42);

test/entt/entity/group.cpp

@@ -319,7 +319,7 @@ TEST(NonOwningGroup, SortAsAPool) {
     }
 
     registry.sort<unsigned int>(std::less<unsigned int>{});
-    group.sort_as(*group.storage<unsigned int>()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    group.sort_as(*group.storage<unsigned int>()); // NOLINT
 
     ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
     ASSERT_EQ((group.get<0, 1>(e1)), (std::make_tuple(1, 1u)));

test/entt/entity/helper.cpp

@@ -70,7 +70,7 @@ TYPED_TEST(ToEntity, Functionalities) {
     constexpr auto page_size = entt::storage_type_t<value_type>::traits_type::page_size;
     const value_type value{42};
 
-    ASSERT_EQ(entt::to_entity(registry, value_type{42}), null); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(entt::to_entity(registry, value_type{42}), null); // NOLINT
     ASSERT_EQ(entt::to_entity(storage, value), null);
 
     const auto entity = registry.create();
@@ -86,7 +86,7 @@ TYPED_TEST(ToEntity, Functionalities) {
     registry.emplace<value_type>(other);
     registry.emplace<value_type>(next);
 
-    ASSERT_EQ(entt::to_entity(registry, registry.get<value_type>(entity)), entity); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(entt::to_entity(registry, registry.get<value_type>(entity)), entity); // NOLINT
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(other)), other);
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(next)), next);
 

test/entt/entity/sigh_mixin.cpp

@@ -347,14 +347,14 @@ TYPED_TEST(SighMixin, Move) {
     ASSERT_FALSE(other.empty());
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
     ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
 
     pool = std::move(other);
 
     ASSERT_FALSE(pool.empty());
-    ASSERT_TRUE(other.empty()); // NOLINT
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_TRUE(other.empty());              // NOLINT
+    ASSERT_EQ(pool.at(0u), entt::entity{3}); // NOLINT
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{3});
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
 
@@ -367,7 +367,7 @@ TYPED_TEST(SighMixin, Move) {
     ASSERT_TRUE(pool.empty()); // NOLINT
     ASSERT_FALSE(other.empty());
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
     ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
 
     other.clear();
@@ -411,8 +411,8 @@ TYPED_TEST(SighMixin, Swap) {
     ASSERT_EQ(pool.size(), 1u + traits_type::in_place_delete);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3});
-    ASSERT_EQ(other.at(0u), entt::entity{42});
+    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3}); // NOLINT
+    ASSERT_EQ(other.at(0u), entt::entity{42});                         // NOLINT
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{2});
     ASSERT_EQ(other.get(entt::entity{42}), value_type{41});
@@ -620,8 +620,8 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_TRUE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[1u]);
-    ASSERT_EQ(pool.at(1u), entity[0u]);
+    ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
+    ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
     ASSERT_EQ(pool.get(entity[1u]), value[0u]);
@@ -632,7 +632,7 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_FALSE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[0u]);
+    ASSERT_EQ(pool.at(0u), entity[0u]); // NOLINT
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
 
     ASSERT_EQ(on_construct, 2u);

test/entt/entity/sparse_set.cpp

@@ -101,7 +101,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(other.policy(), policy);
 
         ASSERT_EQ(set.at(0u), static_cast<entity_type>(entt::null)); // NOLINT
-        ASSERT_EQ(other.at(0u), entity_type{42});
+        ASSERT_EQ(other.at(0u), entity_type{42});                    // NOLINT
 
         sparse_set_type extended{std::move(other), allocator_type{}};
 
@@ -112,7 +112,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(extended.policy(), policy);
 
         ASSERT_EQ(other.at(0u), static_cast<entity_type>(entt::null)); // NOLINT
-        ASSERT_EQ(extended.at(0u), entity_type{42});
+        ASSERT_EQ(extended.at(0u), entity_type{42});                   // NOLINT
 
         set = std::move(extended);
 
@@ -124,7 +124,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(other.policy(), policy);    // NOLINT
         ASSERT_EQ(extended.policy(), policy); // NOLINT
 
-        ASSERT_EQ(set.at(0u), entity_type{42});
+        ASSERT_EQ(set.at(0u), entity_type{42});                           // NOLINT
         ASSERT_EQ(other.at(0u), static_cast<entity_type>(entt::null));    // NOLINT
         ASSERT_EQ(extended.at(0u), static_cast<entity_type>(entt::null)); // NOLINT
 
@@ -139,7 +139,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(other.policy(), policy);
 
         ASSERT_EQ(set.at(0u), static_cast<entity_type>(entt::null)); // NOLINT
-        ASSERT_EQ(other.at(0u), entity_type{42});
+        ASSERT_EQ(other.at(0u), entity_type{42});                    // NOLINT
     }
 }
 
@@ -171,8 +171,8 @@ TYPED_TEST(SparseSet, Swap) {
         ASSERT_EQ(set.size(), 2u);
         ASSERT_EQ(other.size(), 1u);
 
-        ASSERT_EQ(set.at(1u), entity_type{3});
-        ASSERT_EQ(other.at(0u), entity_type{42});
+        ASSERT_EQ(set.at(1u), entity_type{3});    // NOLINT
+        ASSERT_EQ(other.at(0u), entity_type{42}); // NOLINT
     }
 }
 
@@ -958,8 +958,8 @@ TYPED_TEST(SparseSet, Indexing) {
 
         ASSERT_EQ(set.size(), 0u);
 
-        ASSERT_EQ(set.at(0u), static_cast<entity_type>(entt::null));
-        ASSERT_EQ(set.at(99u), static_cast<entity_type>(entt::null));
+        ASSERT_EQ(set.at(0u), static_cast<entity_type>(entt::null));  // NOLINT
+        ASSERT_EQ(set.at(99u), static_cast<entity_type>(entt::null)); // NOLINT
 
         const entity_type entity{42};
         const entity_type other{3};
@@ -969,16 +969,16 @@ TYPED_TEST(SparseSet, Indexing) {
 
         ASSERT_EQ(set.size(), 2u);
 
-        ASSERT_EQ(set.at(0u), entity);
-        ASSERT_EQ(set.at(1u), other);
+        ASSERT_EQ(set.at(0u), entity); // NOLINT
+        ASSERT_EQ(set.at(1u), other);  // NOLINT
 
-        ASSERT_EQ(set.at(0u), set[0u]);
-        ASSERT_EQ(set.at(1u), set[1u]);
+        ASSERT_EQ(set.at(0u), set[0u]); // NOLINT
+        ASSERT_EQ(set.at(1u), set[1u]); // NOLINT
 
-        ASSERT_EQ(set.at(0u), set.data()[0u]);
-        ASSERT_EQ(set.at(1u), set.data()[1u]);
+        ASSERT_EQ(set.at(0u), set.data()[0u]); // NOLINT
+        ASSERT_EQ(set.at(1u), set.data()[1u]); // NOLINT
 
-        ASSERT_EQ(set.at(2u), static_cast<entity_type>(entt::null));
+        ASSERT_EQ(set.at(2u), static_cast<entity_type>(entt::null)); // NOLINT
     }
 }
 
@@ -1053,8 +1053,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1063,8 +1063,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1072,8 +1072,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(std::begin(entity), std::end(entity)), entity[0u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1087,8 +1087,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1097,8 +1097,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[1u]);
-            ASSERT_EQ(set.at(1u), entity[0u]);
+            ASSERT_EQ(set.at(0u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[0u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1106,8 +1106,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(std::begin(entity), std::end(entity)), entity[0u]);
             ASSERT_EQ(set.size(), 4u);
 
-            ASSERT_EQ(set.at(2u), entity[0u]);
-            ASSERT_EQ(set.at(3u), entity[1u]);
+            ASSERT_EQ(set.at(2u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(3u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
             set.compact();
@@ -1124,8 +1124,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1136,8 +1136,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1147,8 +1147,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]);
-            ASSERT_EQ(set.at(1u), entity[1u]);
+            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1868,7 +1868,7 @@ TYPED_TEST(SparseSet, SortAsDisjoint) {
 
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
 
-        lhs.sort_as(rhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        lhs.sort_as(rhs); // NOLINT
 
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
     }
@@ -1891,7 +1891,7 @@ TYPED_TEST(SparseSet, SortAsOverlap) {
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
 
-        lhs.sort_as(rhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        lhs.sort_as(rhs); // NOLINT
 
         auto begin = lhs.begin();
         auto end = lhs.end();
@@ -1920,7 +1920,7 @@ TYPED_TEST(SparseSet, SortAsOrdered) {
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
 
-        rhs.sort_as(lhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        rhs.sort_as(lhs); // NOLINT
 
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
     }
@@ -1943,7 +1943,7 @@ TYPED_TEST(SparseSet, SortAsReverse) {
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
 
-        rhs.sort_as(lhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        rhs.sort_as(lhs); // NOLINT
 
         auto begin = rhs.begin();
         auto end = rhs.end();
@@ -1975,7 +1975,7 @@ TYPED_TEST(SparseSet, SortAsUnordered) {
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
 
-        rhs.sort_as(lhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        rhs.sort_as(lhs); // NOLINT
 
         auto begin = rhs.begin();
         auto end = rhs.end();
@@ -2008,7 +2008,7 @@ TYPED_TEST(SparseSet, SortAsInvalid) {
         ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.begin(), lhs.end()));
         ASSERT_TRUE(std::equal(std::rbegin(rhs_entity), std::rend(rhs_entity), rhs.begin(), rhs.end()));
 
-        rhs.sort_as(lhs); // NOLINT(clang-diagnostic-deprecated-declarations)
+        rhs.sort_as(lhs); // NOLINT
 
         auto begin = rhs.begin();
         auto end = rhs.end();
@@ -2041,7 +2041,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
             lhs.push(entity);
             lhs.erase(entity);
 
-            ASSERT_DEATH(lhs.sort_as(rhs), ""); // NOLINT(clang-diagnostic-deprecated-declarations)
+            ASSERT_DEATH(lhs.sort_as(rhs), ""); // NOLINT
         } break;
         case entt::deletion_policy::swap_only: {
             entity_type entity[3u]{entity_type{3}, entity_type{42}, entity_type{9}};
@@ -2051,7 +2051,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
             lhs.erase(entity[0u]);
             lhs.bump(entity[0u]);
 
-            ASSERT_DEATH(lhs.sort_as(rhs), ""); // NOLINT(clang-diagnostic-deprecated-declarations)
+            ASSERT_DEATH(lhs.sort_as(rhs), ""); // NOLINT
         } break;
         }
     }

test/entt/entity/storage.cpp

@@ -112,7 +112,7 @@ TYPED_TEST(Storage, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 
     ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
 
@@ -125,7 +125,7 @@ TYPED_TEST(Storage, Move) {
     ASSERT_EQ(extended.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(extended.at(0u), entt::entity{3});
+    ASSERT_EQ(extended.at(0u), entt::entity{3});                    // NOLINT
 
     ASSERT_EQ(extended.get(entt::entity{3}), value_type{3});
 
@@ -139,7 +139,7 @@ TYPED_TEST(Storage, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());    // NOLINT
     ASSERT_EQ(extended.type(), entt::type_id<value_type>()); // NOLINT
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_EQ(pool.at(0u), entt::entity{3});                           // NOLINT
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));    // NOLINT
     ASSERT_EQ(extended.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
 
@@ -156,7 +156,7 @@ TYPED_TEST(Storage, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 
     ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
 }
@@ -186,8 +186,8 @@ TYPED_TEST(Storage, Swap) {
     ASSERT_EQ(pool.size(), 1u + traits_type::in_place_delete);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3});
-    ASSERT_EQ(other.at(0u), entt::entity{42});
+    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3}); // NOLINT
+    ASSERT_EQ(other.at(0u), entt::entity{42});                         // NOLINT
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{2});
     ASSERT_EQ(other.get(entt::entity{42}), value_type{41});
@@ -841,14 +841,14 @@ TYPED_TEST(Storage, Insert) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 4u);
-        ASSERT_EQ(pool.at(2u), entity[1u]);
-        ASSERT_EQ(pool.at(3u), entity[0u]);
+        ASSERT_EQ(pool.at(2u), entity[1u]); // NOLINT
+        ASSERT_EQ(pool.at(3u), entity[0u]); // NOLINT
         ASSERT_EQ(pool.index(entity[0u]), 3u);
         ASSERT_EQ(pool.index(entity[1u]), 2u);
     } else {
         ASSERT_EQ(pool.size(), 2u);
-        ASSERT_EQ(pool.at(0u), entity[1u]);
-        ASSERT_EQ(pool.at(1u), entity[0u]);
+        ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
+        ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
         ASSERT_EQ(pool.index(entity[0u]), 1u);
         ASSERT_EQ(pool.index(entity[1u]), 0u);
     }
@@ -872,7 +872,7 @@ TYPED_TEST(Storage, Erase) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 3u);
-        ASSERT_TRUE(pool.at(2u) == entt::tombstone);
+        ASSERT_TRUE(pool.at(2u) == entt::tombstone); // NOLINT
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -893,7 +893,7 @@ TYPED_TEST(Storage, Erase) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 6u);
-        ASSERT_TRUE(pool.at(5u) == entt::tombstone);
+        ASSERT_TRUE(pool.at(5u) == entt::tombstone); // NOLINT
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -931,7 +931,7 @@ TYPED_TEST(Storage, Remove) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 3u);
-        ASSERT_TRUE(pool.at(2u) == entt::tombstone);
+        ASSERT_TRUE(pool.at(2u) == entt::tombstone); // NOLINT
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -953,7 +953,7 @@ TYPED_TEST(Storage, Remove) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 6u);
-        ASSERT_TRUE(pool.at(5u) == entt::tombstone);
+        ASSERT_TRUE(pool.at(5u) == entt::tombstone); // NOLINT
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -1833,8 +1833,8 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_TRUE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[1u]);
-    ASSERT_EQ(pool.at(1u), entity[0u]);
+    ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
+    ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
     ASSERT_EQ(pool.get(entity[1u]), value[0u]);
@@ -1845,7 +1845,7 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_FALSE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[0u]);
+    ASSERT_EQ(pool.at(0u), entity[0u]); // NOLINT
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
 }
 

test/entt/entity/storage_entity.cpp

@@ -43,7 +43,7 @@ TEST(StorageEntity, Move) {
     ASSERT_EQ(other.type(), entt::type_id<void>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 
     entt::storage<entt::entity> extended{std::move(other), std::allocator<entt::entity>{}};
 
@@ -54,7 +54,7 @@ TEST(StorageEntity, Move) {
     ASSERT_EQ(extended.type(), entt::type_id<void>());
 
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(extended.at(0u), entt::entity{3});
+    ASSERT_EQ(extended.at(0u), entt::entity{3});                    // NOLINT
 
     pool = std::move(extended);
 
@@ -66,7 +66,7 @@ TEST(StorageEntity, Move) {
     ASSERT_EQ(other.type(), entt::type_id<void>());    // NOLINT
     ASSERT_EQ(extended.type(), entt::type_id<void>()); // NOLINT
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_EQ(pool.at(0u), entt::entity{3});                           // NOLINT
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));    // NOLINT
     ASSERT_EQ(extended.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
 
@@ -81,7 +81,7 @@ TEST(StorageEntity, Move) {
     ASSERT_EQ(other.type(), entt::type_id<void>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 }
 
 TEST(StorageEntity, Swap) {
@@ -108,8 +108,8 @@ TEST(StorageEntity, Swap) {
     ASSERT_EQ(pool.size(), 10u);
     ASSERT_EQ(other.size(), 43u);
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
-    ASSERT_EQ(other.at(0u), entt::entity{42});
+    ASSERT_EQ(pool.at(0u), entt::entity{3});   // NOLINT
+    ASSERT_EQ(other.at(0u), entt::entity{42}); // NOLINT
 }
 
 TEST(StorageEntity, Getters) {
@@ -153,13 +153,13 @@ TEST(StorageEntity, Emplace) {
     ASSERT_EQ(pool.emplace(traits_type::construct(1, 1)), entt::entity{4});
     ASSERT_EQ(pool.emplace(traits_type::construct(6, 3)), traits_type::construct(6, 3));
 
-    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{1}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{2}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{4}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_GE(pool.index(entt::entity{5}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(traits_type::construct(6, 3)), pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{1}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{2}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{4}), pool.in_use());              // NOLINT
+    ASSERT_GE(pool.index(entt::entity{5}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(traits_type::construct(6, 3)), pool.in_use()); // NOLINT
 
     ASSERT_EQ(pool.emplace(traits_type::construct(5, 42)), traits_type::construct(5, 42));
     ASSERT_EQ(pool.emplace(traits_type::construct(5, 43)), entt::entity{7});
@@ -186,12 +186,12 @@ TEST(StorageEntity, TryEmplace) {
     ASSERT_EQ(*pool.push(traits_type::construct(1, 1)), entt::entity{3});
     ASSERT_EQ(*pool.push(traits_type::construct(5, 3)), traits_type::construct(5, 3));
 
-    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{1}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{2}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_GE(pool.index(entt::entity{4}), pool.in_use());              // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(traits_type::construct(5, 3)), pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{1}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{2}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());              // NOLINT
+    ASSERT_GE(pool.index(entt::entity{4}), pool.in_use());              // NOLINT
+    ASSERT_LT(pool.index(traits_type::construct(5, 3)), pool.in_use()); // NOLINT
 
     ASSERT_EQ(*pool.push(traits_type::construct(4, 42)), traits_type::construct(4, 42));
     ASSERT_EQ(*pool.push(traits_type::construct(4, 43)), entt::entity{6});
@@ -205,12 +205,12 @@ TEST(StorageEntity, TryEmplace) {
     ASSERT_EQ(pool.current(entity[1u]), 4);
     ASSERT_EQ(pool.current(entt::entity{2}), 1);
 
-    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());               // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_GE(pool.index(traits_type::construct(1, 1)), pool.in_use());  // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_GE(pool.index(traits_type::construct(2, 1)), pool.in_use());  // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());               // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_LT(pool.index(traits_type::construct(4, 42)), pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
-    ASSERT_GE(pool.index(traits_type::construct(5, 4)), pool.in_use());  // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());               // NOLINT
+    ASSERT_GE(pool.index(traits_type::construct(1, 1)), pool.in_use());  // NOLINT
+    ASSERT_GE(pool.index(traits_type::construct(2, 1)), pool.in_use());  // NOLINT
+    ASSERT_LT(pool.index(entt::entity{3}), pool.in_use());               // NOLINT
+    ASSERT_LT(pool.index(traits_type::construct(4, 42)), pool.in_use()); // NOLINT
+    ASSERT_GE(pool.index(traits_type::construct(5, 4)), pool.in_use());  // NOLINT
 
     ASSERT_EQ(*pool.push(entt::null), traits_type::construct(2, 1));
     ASSERT_EQ(*pool.push(traits_type::construct(1, 3)), traits_type::construct(1, 3));
@@ -251,13 +251,13 @@ TEST(StorageEntity, Insert) {
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
-    ASSERT_EQ(pool.in_use(), 2u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 2u); // NOLINT
 
     pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
-    ASSERT_EQ(pool.in_use(), 0u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 0u); // NOLINT
 
     pool.insert(entity, entity + 1u);
 
@@ -266,7 +266,7 @@ TEST(StorageEntity, Insert) {
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
-    ASSERT_EQ(pool.in_use(), 1u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 1u); // NOLINT
 }
 
 TEST(StorageEntity, Pack) {
@@ -276,7 +276,7 @@ TEST(StorageEntity, Pack) {
     pool.push(entity, entity + 3u);
     std::swap(entity[0u], entity[1u]);
 
-    const auto len = pool.pack(entity + 1u, entity + 3u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    const auto len = pool.pack(entity + 1u, entity + 3u); // NOLINT
     auto it = pool.each().cbegin().base();
 
     ASSERT_NE(it, pool.cbegin());
@@ -299,17 +299,17 @@ TEST(StorageEntity, InUse) {
 
     pool.emplace(entt::entity{0});
 
-    ASSERT_EQ(pool.in_use(), 1u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 1u); // NOLINT
     ASSERT_EQ(pool.free_list(), 1u);
 
-    pool.in_use(0u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    pool.in_use(0u); // NOLINT
 
-    ASSERT_EQ(pool.in_use(), 0u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 0u); // NOLINT
     ASSERT_EQ(pool.free_list(), 0u);
 
-    pool.in_use(1u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    pool.in_use(1u); // NOLINT
 
-    ASSERT_EQ(pool.in_use(), 1u); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(pool.in_use(), 1u); // NOLINT
     ASSERT_EQ(pool.free_list(), 1u);
 }
 
@@ -318,7 +318,7 @@ ENTT_DEBUG_TEST(StorageEntityDeathTest, InUse) {
 
     pool.emplace(entt::entity{0});
 
-    ASSERT_DEATH(pool.in_use(2u), ""); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_DEATH(pool.in_use(2u), ""); // NOLINT
 }
 
 TEST(StorageEntity, Iterable) {
@@ -348,7 +348,7 @@ TEST(StorageEntity, Iterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_NE(begin.base(), pool.begin());
-    ASSERT_EQ(begin.base(), pool.end() - pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(begin.base(), pool.end() - pool.in_use()); // NOLINT
     ASSERT_EQ(end.base(), pool.end());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{42});
@@ -392,7 +392,7 @@ TEST(StorageEntity, ConstIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_NE(begin.base(), pool.begin());
-    ASSERT_EQ(begin.base(), pool.end() - pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(begin.base(), pool.end() - pool.in_use()); // NOLINT
     ASSERT_EQ(end.base(), pool.end());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{42});
@@ -460,7 +460,7 @@ TEST(StorageEntity, ReverseIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_EQ(begin.base(), pool.rbegin());
-    ASSERT_EQ(end.base(), pool.rbegin() + pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(end.base(), pool.rbegin() + pool.in_use()); // NOLINT
     ASSERT_NE(end.base(), pool.rend());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{1});
@@ -504,7 +504,7 @@ TEST(StorageEntity, ReverseConstIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_EQ(begin.base(), pool.rbegin());
-    ASSERT_EQ(end.base(), pool.rbegin() + pool.in_use()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_EQ(end.base(), pool.rbegin() + pool.in_use()); // NOLINT
     ASSERT_NE(end.base(), pool.rend());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{1});

test/entt/entity/storage_no_instance.cpp

@@ -86,7 +86,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 
     entt::storage<value_type> extended{std::move(other), std::allocator<value_type>{}};
 
@@ -97,7 +97,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_EQ(extended.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(extended.at(0u), entt::entity{3});
+    ASSERT_EQ(extended.at(0u), entt::entity{3});                    // NOLINT
 
     pool = std::move(extended);
 
@@ -109,7 +109,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());    // NOLINT
     ASSERT_EQ(extended.type(), entt::type_id<value_type>()); // NOLINT
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_EQ(pool.at(0u), entt::entity{3});                           // NOLINT
     ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));    // NOLINT
     ASSERT_EQ(extended.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
 
@@ -124,7 +124,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
     ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null)); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{3});                      // NOLINT
 }
 
 TYPED_TEST(StorageNoInstance, Swap) {
@@ -152,8 +152,8 @@ TYPED_TEST(StorageNoInstance, Swap) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
-    ASSERT_EQ(other.at(0u), entt::entity{42});
+    ASSERT_EQ(pool.at(0u), entt::entity{3});   // NOLINT
+    ASSERT_EQ(other.at(0u), entt::entity{42}); // NOLINT
 }
 
 TYPED_TEST(StorageNoInstance, Getters) {

test/entt/entity/view.cpp

@@ -174,8 +174,8 @@ TEST(SingleComponentView, ElementAccess) {
     registry.emplace<int>(e1, 3);
 
     for(auto i = 0u; i < view.size(); ++i) {
-        ASSERT_EQ(view[i], i ? e0 : e1); // NOLINT(clang-diagnostic-deprecated-declarations)
-        ASSERT_EQ(cview[i], i ? e0 : e1); // NOLINT(clang-diagnostic-deprecated-declarations)
+        ASSERT_EQ(view[i], i ? e0 : e1); // NOLINT
+        ASSERT_EQ(cview[i], i ? e0 : e1); // NOLINT
     }
 
     ASSERT_EQ(view[e0], 42);

test/entt/meta/meta_any.cpp

@@ -120,7 +120,7 @@ TEST_F(MetaAny, SBO) {
     entt::meta_any any{'c'};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
     ASSERT_FALSE(any.try_cast<std::size_t>());
     ASSERT_EQ(any.cast<char>(), 'c');
@@ -134,7 +134,7 @@ TEST_F(MetaAny, NoSBO) {
     entt::meta_any any{instance};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
     ASSERT_FALSE(any.try_cast<std::size_t>());
     ASSERT_EQ(any.cast<fat_t>(), instance);
@@ -180,7 +180,7 @@ TEST_F(MetaAny, SBOAsRefConstruction) {
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
     ASSERT_EQ(any.type(), entt::resolve<int>());
 
@@ -217,7 +217,7 @@ TEST_F(MetaAny, SBOAsConstRefConstruction) {
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
     ASSERT_EQ(any.type(), entt::resolve<int>());
 
@@ -450,7 +450,7 @@ TEST_F(MetaAny, NoSBOAsRefConstruction) {
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
 
@@ -485,7 +485,7 @@ TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
 
@@ -723,7 +723,7 @@ TEST_F(MetaAny, VoidInPlaceTypeConstruction) {
     entt::meta_any any{std::in_place_type<void>};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
     ASSERT_FALSE(any.try_cast<char>());
     ASSERT_EQ(any.data(), nullptr);

test/entt/meta/meta_container.cpp

@@ -477,7 +477,7 @@ TEST(AssociativeContainer, StdMap) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_FALSE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
     ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
@@ -521,7 +521,7 @@ TEST(AssociativeContainer, StdSet) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_TRUE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::meta_type{});
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
@@ -568,7 +568,7 @@ TEST(AssociativeContainer, DenseMap) {
     map.emplace(4, '3');
 
     ASSERT_TRUE(view);
-    ASSERT_FALSE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
     ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
@@ -616,7 +616,7 @@ TEST(AssociativeContainer, DenseSet) {
     set.emplace(4);
 
     ASSERT_TRUE(view);
-    ASSERT_TRUE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::meta_type{});
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
@@ -659,7 +659,7 @@ TEST(KeyValueAssociativeContainer, Constness) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_FALSE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_FALSE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
     ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
@@ -702,7 +702,7 @@ TEST(KeyOnlyAssociativeContainer, Constness) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_TRUE(view.key_only()); // NOLINT(clang-diagnostic-deprecated-declarations)
+    ASSERT_TRUE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::meta_type{});
     ASSERT_EQ(view.value_type(), (entt::resolve<int>()));