test: prepare to cleanup clang-tidy config and track things to review in future

test/entt/container/dense_map.cpp

@@ -100,7 +100,7 @@ TEST(DenseMap, Constructors) {
     map = entt::dense_map<int, int>{2u * minimum_bucket_count, std::allocator<float>{}};
     map = entt::dense_map<int, int>{4u * minimum_bucket_count, std::hash<int>(), std::allocator<double>{}};
 
-    map.emplace(3u, 42u);
+    map.emplace(3u, 42u); // NOLINT
 
     entt::dense_map<int, int> temp{map, map.get_allocator()};
     const entt::dense_map<int, int> other{std::move(temp), map.get_allocator()};
@@ -114,7 +114,7 @@ TEST(DenseMap, Constructors) {
 TEST(DenseMap, Copy) {
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
     map.max_load_factor(map.max_load_factor() - .05f);
-    map.emplace(3u, 42u);
+    map.emplace(3u, 42u); // NOLINT
 
     entt::dense_map<std::size_t, std::size_t, entt::identity> other{map};
 
@@ -122,8 +122,8 @@ TEST(DenseMap, Copy) {
     ASSERT_TRUE(other.contains(3u));
     ASSERT_EQ(map.max_load_factor(), other.max_load_factor());
 
-    map.emplace(1u, 99u);
-    map.emplace(11u, 77u);
+    map.emplace(1u, 99u);  // NOLINT
+    map.emplace(11u, 77u); // NOLINT
     other.emplace(0u, 0u);
     other = map;
 
@@ -146,7 +146,7 @@ TEST(DenseMap, Copy) {
 TEST(DenseMap, Move) {
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
     map.max_load_factor(map.max_load_factor() - .05f);
-    map.emplace(3u, 42u);
+    map.emplace(3u, 42u); // NOLINT
 
     entt::dense_map<std::size_t, std::size_t, entt::identity> other{std::move(map)};
 
@@ -155,8 +155,8 @@ TEST(DenseMap, Move) {
     ASSERT_EQ(map.max_load_factor(), other.max_load_factor());
 
     map = other;
-    map.emplace(1u, 99u);
-    map.emplace(11u, 77u);
+    map.emplace(1u, 99u);  // NOLINT
+    map.emplace(11u, 77u); // NOLINT
     other.emplace(0u, 0u);
     other = std::move(map);
 
@@ -183,7 +183,7 @@ TEST(DenseMap, Iterator) {
     testing::StaticAssertTypeEq<iterator::reference, std::pair<const int &, int &>>();
 
     entt::dense_map<int, int> map;
-    map.emplace(3, 42);
+    map.emplace(3, 42); // NOLINT
 
     iterator end{map.begin()};
     iterator begin{};
@@ -221,7 +221,7 @@ TEST(DenseMap, Iterator) {
     ASSERT_GT(end, begin);
     ASSERT_GE(end, map.end());
 
-    map.emplace(42, 3);
+    map.emplace(42, 3); // NOLINT
     begin = map.begin();
 
     ASSERT_EQ(begin[0u].first, 3);
@@ -236,7 +236,7 @@ TEST(DenseMap, ConstIterator) {
     testing::StaticAssertTypeEq<iterator::reference, std::pair<const int &, const int &>>();
 
     entt::dense_map<int, int> map;
-    map.emplace(3, 42);
+    map.emplace(3, 42); // NOLINT
 
     iterator cend{map.cbegin()};
     iterator cbegin{};
@@ -274,7 +274,7 @@ TEST(DenseMap, ConstIterator) {
     ASSERT_GT(cend, cbegin);
     ASSERT_GE(cend, map.cend());
 
-    map.emplace(42, 3);
+    map.emplace(42, 3); // NOLINT
     cbegin = map.cbegin();
 
     ASSERT_EQ(cbegin[0u].first, 3);
@@ -283,7 +283,7 @@ TEST(DenseMap, ConstIterator) {
 
 TEST(DenseMap, IteratorConversion) {
     entt::dense_map<int, int> map;
-    map.emplace(3, 42);
+    map.emplace(3, 42); // NOLINT
 
     const typename entt::dense_map<int, int>::iterator it = map.begin();
     typename entt::dense_map<int, int>::const_iterator cit = it;
@@ -327,7 +327,7 @@ TEST(DenseMap, Insert) {
     ASSERT_EQ(it->first, 1);
     ASSERT_EQ(it->second, 2);
 
-    value.second = 99;
+    value.second = 99; // NOLINT
     std::tie(it, result) = map.insert(value);
 
     ASSERT_FALSE(result);
@@ -345,14 +345,14 @@ TEST(DenseMap, Insert) {
     ASSERT_EQ(it->first, 3);
     ASSERT_EQ(it->second, 4);
 
-    std::tie(it, result) = map.insert(std::pair<const int, int>{3, 99});
+    std::tie(it, result) = map.insert(std::pair<const int, int>{3, 99}); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 2u);
     ASSERT_EQ(it, --map.end());
     ASSERT_EQ(it->second, 4);
 
-    std::tie(it, result) = map.insert(std::pair<int, unsigned int>{5, 6u});
+    std::tie(it, result) = map.insert(std::pair<int, unsigned int>{5, 6u}); // NOLINT
 
     ASSERT_TRUE(result);
     ASSERT_EQ(map.size(), 3u);
@@ -362,22 +362,22 @@ TEST(DenseMap, Insert) {
     ASSERT_EQ(it->first, 5);
     ASSERT_EQ(it->second, 6);
 
-    std::tie(it, result) = map.insert(std::pair<int, unsigned int>{5, 99u});
+    std::tie(it, result) = map.insert(std::pair<int, unsigned int>{5, 99u}); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 3u);
     ASSERT_EQ(it, --map.end());
     ASSERT_EQ(it->second, 6);
 
-    std::pair<const int, int> range[2u]{std::make_pair(7, 8), std::make_pair(9, 10)};
+    std::pair<const int, int> range[2u]{std::make_pair(7, 8), std::make_pair(9, 10)}; // NOLINT
     map.insert(std::begin(range), std::end(range));
 
     ASSERT_EQ(map.size(), 5u);
     ASSERT_TRUE(map.contains(7));
     ASSERT_NE(map.find(9), map.end());
 
-    range[0u].second = 99;
-    range[1u].second = 99;
+    range[0u].second = 99; // NOLINT
+    range[1u].second = 99; // NOLINT
     map.insert(std::begin(range), std::end(range));
 
     ASSERT_EQ(map.size(), 5u);
@@ -460,7 +460,7 @@ TEST(DenseMap, InsertOrAssign) {
     ASSERT_EQ(it->first, 1);
     ASSERT_EQ(it->second, 2);
 
-    std::tie(it, result) = map.insert_or_assign(key, 99);
+    std::tie(it, result) = map.insert_or_assign(key, 99); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 1u);
@@ -477,14 +477,14 @@ TEST(DenseMap, InsertOrAssign) {
     ASSERT_EQ(it->first, 3);
     ASSERT_EQ(it->second, 4);
 
-    std::tie(it, result) = map.insert_or_assign(3, 99);
+    std::tie(it, result) = map.insert_or_assign(3, 99); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 2u);
     ASSERT_EQ(it, --map.end());
     ASSERT_EQ(it->second, 99);
 
-    std::tie(it, result) = map.insert_or_assign(5, 6u);
+    std::tie(it, result) = map.insert_or_assign(5, 6u); // NOLINT
 
     ASSERT_TRUE(result);
     ASSERT_EQ(map.size(), 3u);
@@ -494,7 +494,7 @@ TEST(DenseMap, InsertOrAssign) {
     ASSERT_EQ(it->first, 5);
     ASSERT_EQ(it->second, 6);
 
-    std::tie(it, result) = map.insert_or_assign(5, 99u);
+    std::tie(it, result) = map.insert_or_assign(5, 99u); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 3u);
@@ -539,7 +539,7 @@ TEST(DenseMap, Emplace) {
     ASSERT_EQ(it->first, 1);
     ASSERT_EQ(it->second, 2);
 
-    std::tie(it, result) = map.emplace(std::make_pair(1, 99));
+    std::tie(it, result) = map.emplace(std::make_pair(1, 99)); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 2u);
@@ -556,14 +556,14 @@ TEST(DenseMap, Emplace) {
     ASSERT_EQ(it->first, 3);
     ASSERT_EQ(it->second, 4);
 
-    std::tie(it, result) = map.emplace(3, 99);
+    std::tie(it, result) = map.emplace(3, 99); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 3u);
     ASSERT_EQ(it, --map.end());
     ASSERT_EQ(it->second, 4);
 
-    std::tie(it, result) = map.emplace(std::piecewise_construct, std::make_tuple(5), std::make_tuple(6u));
+    std::tie(it, result) = map.emplace(std::piecewise_construct, std::make_tuple(5), std::make_tuple(6u)); // NOLINT
 
     ASSERT_TRUE(result);
     ASSERT_EQ(map.size(), 4u);
@@ -573,14 +573,14 @@ TEST(DenseMap, Emplace) {
     ASSERT_EQ(it->first, 5);
     ASSERT_EQ(it->second, 6);
 
-    std::tie(it, result) = map.emplace(std::piecewise_construct, std::make_tuple(5), std::make_tuple(99u));
+    std::tie(it, result) = map.emplace(std::piecewise_construct, std::make_tuple(5), std::make_tuple(99u)); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 4u);
     ASSERT_EQ(it, --map.end());
     ASSERT_EQ(it->second, 6);
 
-    std::tie(it, result) = map.emplace(std::make_pair(1, 99));
+    std::tie(it, result) = map.emplace(std::make_pair(1, 99)); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 4u);
@@ -663,7 +663,7 @@ TEST(DenseMap, TryEmplace) {
     ASSERT_EQ(it->first, 1);
     ASSERT_EQ(it->second, 2);
 
-    std::tie(it, result) = map.try_emplace(1, 99);
+    std::tie(it, result) = map.try_emplace(1, 99); // NOLINT
 
     ASSERT_FALSE(result);
     ASSERT_EQ(map.size(), 1u);
@@ -727,13 +727,13 @@ TEST(DenseMap, TryEmplaceSameBucket) {
 
 TEST(DenseMap, TryEmplaceMovableType) {
     entt::dense_map<int, std::unique_ptr<int>> map;
-    std::unique_ptr<int> value = std::make_unique<int>(42);
+    std::unique_ptr<int> value = std::make_unique<int>(42); // NOLINT
 
     ASSERT_TRUE(map.try_emplace(*value, std::move(value)).second);
     ASSERT_FALSE(map.empty());
     ASSERT_FALSE(value);
 
-    value = std::make_unique<int>(42);
+    value = std::make_unique<int>(42); // NOLINT
 
     ASSERT_FALSE(map.try_emplace(*value, std::move(value)).second);
     ASSERT_TRUE(value);
@@ -769,7 +769,7 @@ TEST(DenseMap, Erase) {
     ASSERT_EQ((--map.end())->first, 5u);
 
     for(std::size_t next{}, last = minimum_bucket_count + 1u; next < last; ++next) {
-        if(next == 1u || next == 8u || next == 6u) {
+        if(next == 1u || next == 8u || next == 6u) { // NOLINT
             ASSERT_FALSE(map.contains(next));
             ASSERT_EQ(map.bucket_size(next), 0u);
         } else {
@@ -853,7 +853,7 @@ TEST(DenseMap, EraseFromBucket) {
 
     map.erase((++map.begin(0u))->first);
     map.erase((++map.begin(2u))->first);
-    map.erase((++map.begin(15u))->first);
+    map.erase((++map.begin(15u))->first); // NOLINT
 
     ASSERT_EQ(map.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_EQ(map.size(), 6u);
@@ -866,8 +866,8 @@ TEST(DenseMap, EraseFromBucket) {
     ASSERT_FALSE(map.contains(2u * minimum_bucket_count * 1u + 2u));
     ASSERT_FALSE(map.contains(2u * minimum_bucket_count * (1u + 1u) - 1u));
 
-    while(map.begin(15) != map.end(15u)) {
-        map.erase(map.begin(15)->first);
+    while(map.begin(15) != map.end(15u)) { // NOLINT
+        map.erase(map.begin(15)->first);   // NOLINT
     }
 
     ASSERT_EQ(map.bucket_count(), 2u * minimum_bucket_count);
@@ -921,7 +921,7 @@ TEST(DenseMap, EqualRange) {
     entt::dense_map<int, int, entt::identity, test::transparent_equal_to> map;
     const auto &cmap = map;
 
-    map.emplace(42, 3);
+    map.emplace(42, 3); // NOLINT
 
     ASSERT_EQ(map.equal_range(0).first, map.end());
     ASSERT_EQ(map.equal_range(0).second, map.end());
@@ -963,7 +963,7 @@ TEST(DenseMap, Indexing) {
 
     ASSERT_FALSE(map.contains(key));
 
-    map[key] = 99;
+    map[key] = 99; // NOLINT
 
     ASSERT_TRUE(map.contains(key));
     ASSERT_EQ(map[int{key}], 99);
@@ -988,8 +988,8 @@ TEST(DenseMap, LocalIterator) {
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
-    map.emplace(3u, 42u);
-    map.emplace(3u + minimum_bucket_count, 99u);
+    map.emplace(3u, 42u);                        // NOLINT
+    map.emplace(3u + minimum_bucket_count, 99u); // NOLINT
 
     iterator end{map.begin(3u)};
     iterator begin{};
@@ -1016,8 +1016,8 @@ TEST(DenseMap, ConstLocalIterator) {
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
-    map.emplace(3u, 42u);
-    map.emplace(3u + minimum_bucket_count, 99u);
+    map.emplace(3u, 42u);                        // NOLINT
+    map.emplace(3u + minimum_bucket_count, 99u); // NOLINT
 
     iterator cend{map.begin(3u)};
     iterator cbegin{};
@@ -1037,7 +1037,7 @@ TEST(DenseMap, ConstLocalIterator) {
 
 TEST(DenseMap, LocalIteratorConversion) {
     entt::dense_map<int, int> map;
-    map.emplace(3, 42);
+    map.emplace(3, 42); // NOLINT
 
     const typename entt::dense_map<int, int>::local_iterator it = map.begin(map.bucket(3));
     typename entt::dense_map<int, int>::const_local_iterator cit = it;
@@ -1057,21 +1057,21 @@ TEST(DenseMap, LocalIteratorConversion) {
 TEST(DenseMap, Rehash) {
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
-    map[32u] = 99u;
+    map[32u] = 99u; // NOLINT
 
     ASSERT_EQ(map.bucket_count(), minimum_bucket_count);
     ASSERT_TRUE(map.contains(32u));
     ASSERT_EQ(map.bucket(32u), 0u);
     ASSERT_EQ(map[32u], 99u);
 
-    map.rehash(12u);
+    map.rehash(12u); // NOLINT
 
     ASSERT_EQ(map.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_TRUE(map.contains(32u));
     ASSERT_EQ(map.bucket(32u), 0u);
     ASSERT_EQ(map[32u], 99u);
 
-    map.rehash(44u);
+    map.rehash(44u); // NOLINT
 
     ASSERT_EQ(map.bucket_count(), 8u * minimum_bucket_count);
     ASSERT_TRUE(map.contains(32u));
@@ -1097,7 +1097,7 @@ TEST(DenseMap, Rehash) {
     ASSERT_EQ(map.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_TRUE(map.contains(32u));
 
-    map.rehash(55u);
+    map.rehash(55u); // NOLINT
 
     ASSERT_EQ(map.bucket_count(), 8u * minimum_bucket_count);
     ASSERT_TRUE(map.contains(32u));

test/entt/container/dense_set.cpp

@@ -27,7 +27,7 @@ TEST(DenseSet, Functionalities) {
     ASSERT_EQ(set.max_load_factor(), .875f);
     ASSERT_EQ(set.max_size(), (std::vector<std::pair<std::size_t, int>>{}.max_size()));
 
-    set.max_load_factor(.9f);
+    set.max_load_factor(.9f); // NOLINT
 
     ASSERT_EQ(set.max_load_factor(), .9f);
 
@@ -111,7 +111,7 @@ TEST(DenseSet, Constructors) {
 
 TEST(DenseSet, Copy) {
     entt::dense_set<std::size_t, entt::identity> set;
-    set.max_load_factor(set.max_load_factor() - .05f);
+    set.max_load_factor(set.max_load_factor() - .05f); // NOLINT
     set.emplace(3u);
 
     entt::dense_set<std::size_t, entt::identity> other{set};
@@ -121,7 +121,7 @@ TEST(DenseSet, Copy) {
     ASSERT_EQ(set.max_load_factor(), other.max_load_factor());
 
     set.emplace(1u);
-    set.emplace(11u);
+    set.emplace(11u); // NOLINT
     other.emplace(0u);
     other = set;
 
@@ -139,7 +139,7 @@ TEST(DenseSet, Copy) {
 
 TEST(DenseSet, Move) {
     entt::dense_set<std::size_t, entt::identity> set;
-    set.max_load_factor(set.max_load_factor() - .05f);
+    set.max_load_factor(set.max_load_factor() - .05f); // NOLINT
     set.emplace(3u);
 
     entt::dense_set<std::size_t, entt::identity> other{std::move(set)};
@@ -150,7 +150,7 @@ TEST(DenseSet, Move) {
 
     set = other;
     set.emplace(1u);
-    set.emplace(11u);
+    set.emplace(11u); // NOLINT
     other.emplace(0u);
     other = std::move(set);
 
@@ -211,7 +211,7 @@ TEST(DenseSet, Iterator) {
     ASSERT_GT(end, begin);
     ASSERT_GE(end, set.end());
 
-    set.emplace(42);
+    set.emplace(42); // NOLINT
     begin = set.begin();
 
     ASSERT_EQ(begin[0u], 3);
@@ -264,7 +264,7 @@ TEST(DenseSet, ConstIterator) {
     ASSERT_GT(cend, cbegin);
     ASSERT_GE(cend, set.cend());
 
-    set.emplace(42);
+    set.emplace(42); // NOLINT
     cbegin = set.cbegin();
 
     ASSERT_EQ(cbegin[0u], 3);
@@ -317,7 +317,7 @@ TEST(DenseSet, ReverseIterator) {
     ASSERT_GT(end, begin);
     ASSERT_GE(end, set.rend());
 
-    set.emplace(42);
+    set.emplace(42); // NOLINT
     begin = set.rbegin();
 
     ASSERT_EQ(begin[0u], 42);
@@ -370,7 +370,7 @@ TEST(DenseSet, ConstReverseIterator) {
     ASSERT_GT(cend, cbegin);
     ASSERT_GE(cend, set.crend());
 
-    set.emplace(42);
+    set.emplace(42); // NOLINT
     cbegin = set.crbegin();
 
     ASSERT_EQ(cbegin[0u], 42);
@@ -445,7 +445,7 @@ TEST(DenseSet, Insert) {
     ASSERT_EQ(it, --set.end());
     ASSERT_EQ(*it, 3);
 
-    int range[2u]{7, 9};
+    int range[2u]{7, 9}; // NOLINT
     set.insert(std::begin(range), std::end(range));
 
     ASSERT_EQ(set.size(), 4u);
@@ -629,7 +629,7 @@ TEST(DenseSet, Erase) {
     ASSERT_EQ(*--set.end(), 5u);
 
     for(std::size_t next{}, last = minimum_bucket_count + 1u; next < last; ++next) {
-        if(next == 1u || next == 8u || next == 6u) {
+        if(next == 1u || next == 8u || next == 6u) { // NOLINT
             ASSERT_FALSE(set.contains(next));
             ASSERT_EQ(set.bucket_size(next), 0u);
         } else {
@@ -712,7 +712,7 @@ TEST(DenseSet, EraseFromBucket) {
 
     set.erase(*++set.begin(0u));
     set.erase(*++set.begin(2u));
-    set.erase(*++set.begin(15u));
+    set.erase(*++set.begin(15u)); // NOLINT
 
     ASSERT_EQ(set.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_EQ(set.size(), 6u);
@@ -725,8 +725,8 @@ TEST(DenseSet, EraseFromBucket) {
     ASSERT_FALSE(set.contains(2u * minimum_bucket_count * 1u + 2u));
     ASSERT_FALSE(set.contains(2u * minimum_bucket_count * (1u + 1u) - 1u));
 
-    while(set.begin(15) != set.end(15u)) {
-        set.erase(*set.begin(15));
+    while(set.begin(15) != set.end(15u)) { // NOLINT
+        set.erase(*set.begin(15));         // NOLINT
     }
 
     ASSERT_EQ(set.bucket_count(), 2u * minimum_bucket_count);
@@ -780,7 +780,7 @@ TEST(DenseSet, EqualRange) {
     entt::dense_set<int, entt::identity, test::transparent_equal_to> set;
     const auto &cset = set;
 
-    set.emplace(42);
+    set.emplace(42); // NOLINT
 
     ASSERT_EQ(set.equal_range(0).first, set.end());
     ASSERT_EQ(set.equal_range(0).second, set.end());
@@ -895,13 +895,13 @@ TEST(DenseSet, Rehash) {
     ASSERT_TRUE(set.contains(32u));
     ASSERT_EQ(set.bucket(32u), 0u);
 
-    set.rehash(12u);
+    set.rehash(12u); // NOLINT
 
     ASSERT_EQ(set.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_TRUE(set.contains(32u));
     ASSERT_EQ(set.bucket(32u), 0u);
 
-    set.rehash(44u);
+    set.rehash(44u); // NOLINT
 
     ASSERT_EQ(set.bucket_count(), 8u * minimum_bucket_count);
     ASSERT_TRUE(set.contains(32u));
@@ -925,7 +925,7 @@ TEST(DenseSet, Rehash) {
     ASSERT_EQ(set.bucket_count(), 2u * minimum_bucket_count);
     ASSERT_TRUE(set.contains(32u));
 
-    set.rehash(55u);
+    set.rehash(55u); // NOLINT
 
     ASSERT_EQ(set.bucket_count(), 8u * minimum_bucket_count);
     ASSERT_TRUE(set.contains(32u));

test/entt/core/algorithm.cpp

@@ -7,19 +7,19 @@
 
 TEST(Algorithm, StdSort) {
     // well, I'm pretty sure it works, it's std::sort!!
-    std::array<int, 5> arr{{4, 1, 3, 2, 0}};
+    std::array<int, 5> arr{{4, 1, 3, 2, 0}}; // NOLINT
     const entt::std_sort sort;
 
     sort(arr.begin(), arr.end());
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_LT(arr[i], arr[i + 1u]);
+        ASSERT_LT(arr[i], arr[i + 1u]); // NOLINT
     }
 }
 
 TEST(Algorithm, StdSortBoxedInt) {
     // well, I'm pretty sure it works, it's std::sort!!
-    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}};
+    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}}; // NOLINT
     const entt::std_sort sort;
 
     sort(arr.begin(), arr.end(), [](const auto &lhs, const auto &rhs) {
@@ -27,23 +27,23 @@ TEST(Algorithm, StdSortBoxedInt) {
     });
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_GT(arr[i].value, arr[i + 1u].value);
+        ASSERT_GT(arr[i].value, arr[i + 1u].value); // NOLINT
     }
 }
 
 TEST(Algorithm, InsertionSort) {
-    std::array<int, 5> arr{{4, 1, 3, 2, 0}};
+    std::array<int, 5> arr{{4, 1, 3, 2, 0}}; // NOLINT
     const entt::insertion_sort sort;
 
     sort(arr.begin(), arr.end());
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_LT(arr[i], arr[i + 1u]);
+        ASSERT_LT(arr[i], arr[i + 1u]); // NOLINT
     }
 }
 
 TEST(Algorithm, InsertionSortBoxedInt) {
-    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}};
+    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}}; // NOLINT
     const entt::insertion_sort sort;
 
     sort(arr.begin(), arr.end(), [](const auto &lhs, const auto &rhs) {
@@ -51,7 +51,7 @@ TEST(Algorithm, InsertionSortBoxedInt) {
     });
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_GT(arr[i].value, arr[i + 1u].value);
+        ASSERT_GT(arr[i].value, arr[i + 1u].value); // NOLINT
     }
 }
 
@@ -63,7 +63,7 @@ TEST(Algorithm, InsertionSortEmptyContainer) {
 }
 
 TEST(Algorithm, RadixSort) {
-    std::array<std::uint32_t, 5> arr{{4, 1, 3, 2, 0}};
+    std::array<std::uint32_t, 5> arr{{4, 1, 3, 2, 0}}; // NOLINT
     const entt::radix_sort<8, 32> sort;
 
     sort(arr.begin(), arr.end(), [](const auto &value) {
@@ -71,12 +71,12 @@ TEST(Algorithm, RadixSort) {
     });
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_LT(arr[i], arr[i + 1u]);
+        ASSERT_LT(arr[i], arr[i + 1u]); // NOLINT
     }
 }
 
 TEST(Algorithm, RadixSortBoxedInt) {
-    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}};
+    std::array<test::boxed_int, 6> arr{{{4}, {1}, {3}, {2}, {0}, {6}}}; // NOLINT
     const entt::radix_sort<2, 6> sort;
 
     sort(arr.rbegin(), arr.rend(), [](const auto &instance) {
@@ -84,7 +84,7 @@ TEST(Algorithm, RadixSortBoxedInt) {
     });
 
     for(auto i = 0u; i < (arr.size() - 1u); ++i) {
-        ASSERT_GT(arr[i].value, arr[i + 1u].value);
+        ASSERT_GT(arr[i].value, arr[i + 1u].value); // NOLINT
     }
 }
 

test/entt/core/any.cpp

@@ -44,7 +44,7 @@ struct fat {
     }
 
     inline static int counter{0}; // NOLINT
-    double value[4];
+    double value[4];              // NOLINT
 };
 
 struct alignas(64u) over_aligned {};
@@ -93,7 +93,7 @@ TEST_F(Any, Empty) {
 }
 
 TEST_F(Any, SBOInPlaceTypeConstruction) {
-    entt::any any{std::in_place_type<int>, 42};
+    entt::any any{std::in_place_type<int>, 42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(any.owner()); // NOLINT
@@ -113,7 +113,7 @@ TEST_F(Any, SBOInPlaceTypeConstruction) {
 }
 
 TEST_F(Any, SBOAsRefConstruction) {
-    int value = 42;
+    int value = 42; // NOLINT
     entt::any any{entt::forward_as_any(value)};
 
     ASSERT_TRUE(any);
@@ -221,7 +221,7 @@ TEST_F(Any, SBOCopyAssignment) {
 }
 
 TEST_F(Any, SBOMoveConstruction) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     entt::any other{std::move(any)};
 
     ASSERT_TRUE(any); // NOLINT
@@ -236,7 +236,7 @@ TEST_F(Any, SBOMoveConstruction) {
 }
 
 TEST_F(Any, SBOMoveAssignment) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     entt::any other{3};
 
     other = std::move(any);
@@ -254,7 +254,7 @@ TEST_F(Any, SBOMoveAssignment) {
 
 TEST_F(Any, SBODirectAssignment) {
     entt::any any{};
-    any = 42;
+    any = 42; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
@@ -264,7 +264,7 @@ TEST_F(Any, SBODirectAssignment) {
 }
 
 TEST_F(Any, SBOAssignValue) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     const entt::any other{3};
     const entt::any invalid{'c'};
 
@@ -277,7 +277,7 @@ TEST_F(Any, SBOAssignValue) {
 }
 
 TEST_F(Any, SBOAsRefAssignValue) {
-    int value = 42;
+    int value = 42; // NOLINT
     entt::any any{entt::forward_as_any(value)};
     const entt::any other{3};
     const entt::any invalid{'c'};
@@ -307,7 +307,7 @@ TEST_F(Any, SBOAsConstRefAssignValue) {
 }
 
 TEST_F(Any, SBOTransferValue) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(entt::any_cast<int>(any), 42);
@@ -319,7 +319,7 @@ TEST_F(Any, SBOTransferValue) {
 
 TEST_F(Any, SBOTransferConstValue) {
     const int value = 3;
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(entt::any_cast<int>(any), 42);
@@ -329,7 +329,7 @@ TEST_F(Any, SBOTransferConstValue) {
 }
 
 TEST_F(Any, SBOAsRefTransferValue) {
-    int value = 42;
+    int value = 42; // NOLINT
     entt::any any{entt::forward_as_any(value)};
 
     ASSERT_TRUE(any);
@@ -655,7 +655,7 @@ TEST_F(Any, VoidCopyConstruction) {
 
 TEST_F(Any, VoidCopyAssignment) {
     entt::any any{std::in_place_type<void>};
-    entt::any other{42};
+    entt::any other{42}; // NOLINT
 
     other = any;
 
@@ -685,7 +685,7 @@ TEST_F(Any, VoidMoveConstruction) {
 
 TEST_F(Any, VoidMoveAssignment) {
     entt::any any{std::in_place_type<void>};
-    entt::any other{42};
+    entt::any other{42}; // NOLINT
 
     other = std::move(any);
 
@@ -700,7 +700,7 @@ TEST_F(Any, VoidMoveAssignment) {
 }
 
 TEST_F(Any, SBOMoveValidButUnspecifiedState) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     entt::any other{std::move(any)};
     const entt::any valid = std::move(other);
 
@@ -761,7 +761,7 @@ TEST_F(Any, VoidDestruction) {
 
 TEST_F(Any, Emplace) {
     entt::any any{};
-    any.emplace<int>(42);
+    any.emplace<int>(42); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
@@ -780,7 +780,7 @@ TEST_F(Any, EmplaceVoid) {
 }
 
 TEST_F(Any, Reset) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
@@ -792,7 +792,7 @@ TEST_F(Any, Reset) {
     ASSERT_EQ(any.policy(), entt::any_policy::owner);
     ASSERT_EQ(any.type(), entt::type_id<void>());
 
-    int value = 42;
+    int value = 42; // NOLINT
     any.emplace<int &>(value);
 
     ASSERT_TRUE(any);
@@ -808,7 +808,7 @@ TEST_F(Any, Reset) {
 
 TEST_F(Any, SBOSwap) {
     entt::any lhs{'c'};
-    entt::any rhs{42};
+    entt::any rhs{42}; // NOLINT
 
     std::swap(lhs, rhs);
 
@@ -1037,7 +1037,7 @@ TEST_F(Any, NoSBOWithVoidSwap) {
 }
 
 TEST_F(Any, AsRef) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     auto ref = any.as_ref();
     auto cref = std::as_const(any).as_ref();
 
@@ -1098,8 +1098,8 @@ TEST_F(Any, AsRef) {
     ASSERT_EQ(entt::any_cast<const int &>(ref), 3);
     ASSERT_EQ(entt::any_cast<const int &>(cref), 3);
 
-    ref = 42;
-    cref = 42;
+    ref = 42;  // NOLINT
+    cref = 42; // NOLINT
 
     ASSERT_EQ(ref.policy(), entt::any_policy::owner);
     ASSERT_EQ(cref.policy(), entt::any_policy::owner);
@@ -1143,7 +1143,7 @@ TEST_F(Any, NoSBOComparable) {
 }
 
 TEST_F(Any, RefComparable) {
-    int value = 42;
+    int value = 42; // NOLINT
     const entt::any any{entt::forward_as_any(value)};
     const entt::any other{3};
 
@@ -1158,7 +1158,7 @@ TEST_F(Any, RefComparable) {
 }
 
 TEST_F(Any, ConstRefComparable) {
-    int value = 42;
+    int value = 42; // NOLINT
     const entt::any any{3};
     const entt::any other{entt::make_any<const int &>(value)};
 
@@ -1241,7 +1241,7 @@ TEST_F(Any, CompareVoid) {
 }
 
 TEST_F(Any, AnyCast) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     const auto &cany = any;
 
     ASSERT_EQ(entt::any_cast<char>(&any), nullptr);
@@ -1261,7 +1261,7 @@ TEST_F(Any, AnyCast) {
 }
 
 ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
-    entt::any any{42};
+    entt::any any{42}; // NOLINT
     const auto &cany = any;
 
     ASSERT_DEATH([[maybe_unused]] auto &elem = entt::any_cast<double &>(any), "");
@@ -1276,7 +1276,7 @@ ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
 }
 
 TEST_F(Any, MakeAny) {
-    int value = 42;
+    int value = 42; // NOLINT
     auto any = entt::make_any<int>(value);
     auto ext = entt::make_any<int, sizeof(int), alignof(int)>(value);
     auto ref = entt::make_any<int &>(value);
@@ -1303,7 +1303,7 @@ TEST_F(Any, MakeAny) {
 }
 
 TEST_F(Any, ForwardAsAny) {
-    int value = 42;
+    int value = 42; // NOLINT
     auto ref = entt::forward_as_any(value);
     auto cref = entt::forward_as_any(std::as_const(value));
     auto any = entt::forward_as_any(static_cast<int &&>(value));
@@ -1409,20 +1409,20 @@ TEST_F(Any, NonMovableType) {
 }
 
 TEST_F(Any, Array) {
-    entt::any any{std::in_place_type<int[1]>};
+    entt::any any{std::in_place_type<int[1]>}; // NOLINT
     const entt::any copy{any};
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(copy);
 
-    ASSERT_EQ(any.type(), entt::type_id<int[1]>());
-    ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr);
-    ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr);
+    ASSERT_EQ(any.type(), entt::type_id<int[1]>());   // NOLINT
+    ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr); // NOLINT
+    ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr); // NOLINT
     ASSERT_EQ(entt::any_cast<int *>(&any), nullptr);
 
-    entt::any_cast<int(&)[1]>(any)[0] = 42;
+    entt::any_cast<int(&)[1]>(any)[0] = 42; // NOLINT
 
-    ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 42);
+    ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 42); // NOLINT
 }
 
 TEST_F(Any, CopyMoveReference) {
@@ -1448,7 +1448,7 @@ TEST_F(Any, CopyMoveReference) {
     ASSERT_EQ(entt::any_cast<int>(move), 3);
     ASSERT_EQ(entt::any_cast<int>(copy), 3);
 
-    value = 42;
+    value = 42; // NOLINT
 
     ASSERT_EQ(entt::any_cast<int &>(move), 42);
     ASSERT_EQ(entt::any_cast<int &>(copy), 3);
@@ -1477,20 +1477,20 @@ TEST_F(Any, CopyMoveConstReference) {
     ASSERT_EQ(entt::any_cast<int>(move), 3);
     ASSERT_EQ(entt::any_cast<int>(copy), 3);
 
-    value = 42;
+    value = 42; // NOLINT
 
     ASSERT_EQ(entt::any_cast<const int &>(move), 42);
     ASSERT_EQ(entt::any_cast<const int &>(copy), 3);
 }
 
 TEST_F(Any, SBOVsZeroedSBOSize) {
-    entt::any sbo{42};
+    entt::any sbo{42}; // NOLINT
     const auto *broken = sbo.data();
     entt::any other = std::move(sbo);
 
     ASSERT_NE(broken, other.data());
 
-    entt::basic_any<0u> dyn{42};
+    entt::basic_any<0u> dyn{42}; // NOLINT
     const auto *valid = dyn.data();
     entt::basic_any<0u> same = std::move(dyn);
 
@@ -1499,7 +1499,7 @@ TEST_F(Any, SBOVsZeroedSBOSize) {
 
 TEST_F(Any, SboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    entt::basic_any<alignment, alignment> sbo[2] = {over_aligned{}, over_aligned{}};
+    entt::basic_any<alignment, alignment> sbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
     const auto *data = sbo[0].data();
 
     ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(sbo[0u].data()) % alignment) == 0u); // NOLINT
@@ -1515,7 +1515,7 @@ TEST_F(Any, SboAlignment) {
 
 TEST_F(Any, NoSboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    entt::basic_any<alignment> nosbo[2] = {over_aligned{}, over_aligned{}};
+    entt::basic_any<alignment> nosbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
     const auto *data = nosbo[0].data();
 
     ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(nosbo[0u].data()) % alignment) == 0u); // NOLINT
@@ -1531,7 +1531,7 @@ TEST_F(Any, NoSboAlignment) {
 
 TEST_F(Any, AggregatesMustWork) {
     // the goal of this test is to enforce the requirements for aggregate types
-    entt::any{std::in_place_type<test::aggregate>, 42}.emplace<test::aggregate>(42);
+    entt::any{std::in_place_type<test::aggregate>, 42}.emplace<test::aggregate>(42); // NOLINT
 }
 
 TEST_F(Any, DeducedArrayType) {

test/entt/core/compressed_pair.cpp

@@ -34,7 +34,7 @@ TEST(CompressedPair, ConstructCopyMove) {
     static_assert(std::is_move_constructible_v<entt::compressed_pair<std::unique_ptr<int>, test::empty>>, "Move constructible type required");
     static_assert(std::is_move_assignable_v<entt::compressed_pair<std::unique_ptr<int>, test::empty>>, "Move assignable type required");
 
-    entt::compressed_pair copyable{test::non_default_constructible{42}, test::empty{}};
+    entt::compressed_pair copyable{test::non_default_constructible{42}, test::empty{}}; // NOLINT
     auto by_copy{copyable};
 
     ASSERT_EQ(by_copy.first().value, 42);
@@ -44,7 +44,7 @@ TEST(CompressedPair, ConstructCopyMove) {
 
     ASSERT_EQ(copyable.first().value, 3);
 
-    entt::compressed_pair<test::empty, std::unique_ptr<int>> movable{test::empty{}, std::make_unique<int>(99)};
+    entt::compressed_pair<test::empty, std::unique_ptr<int>> movable{test::empty{}, std::make_unique<int>(99)}; // NOLINT
     auto by_move{std::move(movable)};
 
     ASSERT_EQ(*by_move.second(), 99);
@@ -138,7 +138,7 @@ TEST(CompressedPair, Get) {
     testing::StaticAssertTypeEq<decltype(cfirst), const int>();
     testing::StaticAssertTypeEq<decltype(csecond), const int>();
 
-    auto [tfirst, tsecond] = entt::compressed_pair{9, 99};
+    auto [tfirst, tsecond] = entt::compressed_pair{9, 99}; // NOLINT
 
     ASSERT_EQ(tfirst, 9);
     ASSERT_EQ(tsecond, 99);

test/entt/core/iterator.cpp

@@ -10,7 +10,7 @@ TEST(InputIteratorPointer, Functionalities) {
 
     ASSERT_EQ(ptr->value, 0);
 
-    ptr->value = 42;
+    ptr->value = 42; // NOLINT
 
     ASSERT_EQ(ptr->value, 42);
     ASSERT_EQ(ptr->value, (*ptr).value);
@@ -46,7 +46,7 @@ TEST(IterableAdaptor, Functionalities) {
     ASSERT_EQ(*++iterable.cbegin(), 2);
     ASSERT_EQ(++iterable.cbegin(), --iterable.end());
 
-    for(auto value: entt::iterable_adaptor<const int *, const void *>{vec.data(), vec.data() + 1u}) {
+    for(auto value: entt::iterable_adaptor<const int *, const void *>{vec.data(), vec.data() + 1u}) { // NOLINT
         ASSERT_EQ(value, 1);
     }
 }

test/entt/core/memory.cpp

@@ -214,7 +214,7 @@ TEST(MakeObjUsingAllocator, Functionalities) {
 }
 
 TEST(UninitializedConstructUsingAllocator, NoUsesAllocatorConstruction) {
-    alignas(int) std::byte storage[sizeof(int)];
+    alignas(int) std::byte storage[sizeof(int)]; // NOLINT
     const std::allocator<int> allocator{};
 
     int *value = entt::uninitialized_construct_using_allocator(reinterpret_cast<int *>(&storage), allocator, 42); // NOLINT
@@ -230,7 +230,7 @@ TEST(UninitializedConstructUsingAllocator, UsesAllocatorConstruction) {
 
     test::tracked_memory_resource memory_resource{};
     const std::pmr::polymorphic_allocator<string_type> allocator{&memory_resource};
-    alignas(string_type) std::byte storage[sizeof(string_type)];
+    alignas(string_type) std::byte storage[sizeof(string_type)]; // NOLINT
 
     string_type *value = entt::uninitialized_construct_using_allocator(reinterpret_cast<string_type *>(&storage), allocator, test::tracked_memory_resource::default_value); // NOLINT
 

test/entt/core/monostate.cpp

@@ -12,7 +12,7 @@ TEST(Monostate, Functionalities) {
     ASSERT_EQ(i_pre, int{});
 
     entt::monostate<"foobar"_hs>{} = true;
-    entt::monostate_v<"foobar"_hs> = 42;
+    entt::monostate_v<"foobar"_hs> = 42; // NOLINT
 
     const bool &b_post = entt::monostate<"foobar"_hs>{};
     const int &i_post = entt::monostate_v<entt::hashed_string{"foobar"}>;

test/entt/core/tuple.cpp

@@ -11,8 +11,8 @@ TEST(Tuple, IsTuple) {
 }
 
 TEST(Tuple, UnwrapTuple) {
-    auto single = std::make_tuple(42);
-    auto multi = std::make_tuple(42, 'c');
+    auto single = std::make_tuple(42);     // NOLINT
+    auto multi = std::make_tuple(42, 'c'); // NOLINT
     auto ref = std::forward_as_tuple(std::get<0>(single));
 
     testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(single)), int &>();

test/entt/core/type_traits.cpp

@@ -31,7 +31,7 @@ struct clazz {
 };
 
 int free_function(int, const double &) {
-    return 42;
+    return 42; // NOLINT
 }
 
 template<typename, typename Type = void>
@@ -60,8 +60,8 @@ struct UnpackAsValue: ::testing::Test {
 TEST(SizeOf, Functionalities) {
     ASSERT_EQ(entt::size_of_v<void>, 0u);
     ASSERT_EQ(entt::size_of_v<char>, sizeof(char));
-    ASSERT_EQ(entt::size_of_v<int[]>, 0u);
-    ASSERT_EQ(entt::size_of_v<int[3]>, sizeof(int[3]));
+    ASSERT_EQ(entt::size_of_v<int[]>, 0u);              // NOLINT
+    ASSERT_EQ(entt::size_of_v<int[3]>, sizeof(int[3])); // NOLINT
 }
 
 TEST_F(UnpackAsType, Functionalities) {
@@ -165,9 +165,9 @@ TEST(ValueList, Functionalities) {
     ASSERT_EQ((std::tuple_size_v<entt::value_list<42>>), 1u);
     ASSERT_EQ((std::tuple_size_v<entt::value_list<42, 'a'>>), 2u);
 
-    testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42>>>();
-    testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42, 'a'>>>();
-    testing::StaticAssertTypeEq<char, std::tuple_element_t<1, entt::value_list<42, 'a'>>>();
+    testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42>>>();       // NOLINT
+    testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42, 'a'>>>();  // NOLINT
+    testing::StaticAssertTypeEq<char, std::tuple_element_t<1, entt::value_list<42, 'a'>>>(); // NOLINT
 }
 
 TEST(IsApplicable, Functionalities) {
@@ -223,7 +223,7 @@ TEST(IsEqualityComparable, Functionalities) {
     ASSERT_TRUE((entt::is_equality_comparable_v<std::optional<int>>));
     ASSERT_TRUE(entt::is_equality_comparable_v<nlohmann_json_like>);
 
-    ASSERT_FALSE(entt::is_equality_comparable_v<int[3u]>);
+    ASSERT_FALSE(entt::is_equality_comparable_v<int[3u]>); // NOLINT
     ASSERT_FALSE(entt::is_equality_comparable_v<test::non_comparable>);
     ASSERT_FALSE(entt::is_equality_comparable_v<const test::non_comparable>);
     ASSERT_FALSE(entt::is_equality_comparable_v<std::vector<test::non_comparable>>);

test/entt/core/utility.cpp

@@ -13,7 +13,7 @@ struct functions {
 
 TEST(Identity, Functionalities) {
     const entt::identity identity;
-    int value = 42;
+    int value = 42; // NOLINT
 
     ASSERT_TRUE(entt::is_transparent_v<entt::identity>);
     ASSERT_EQ(identity(value), value);
@@ -44,10 +44,10 @@ TEST(Overloaded, Functionalities) {
         [&iv](int value) { iv = value; },
         [&cv](char value) { cv = value; }};
 
-    func(42);
+    func(42); // NOLINT
     func('c');
 
-    ASSERT_EQ(iv, 42);
+    ASSERT_EQ(iv, 42); // NOLINT
     ASSERT_EQ(cv, 'c');
 }
 

test/entt/entity/group.cpp

@@ -23,7 +23,7 @@ TEST(NonOwningGroup, Functionalities) {
     registry.emplace<char>(e0, '1');
 
     const auto e1 = registry.create();
-    registry.emplace<int>(e1, 42);
+    registry.emplace<int>(e1, 42); // NOLINT
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
@@ -175,7 +175,7 @@ TEST(NonOwningGroup, Empty) {
 
 TEST(NonOwningGroup, Each) {
     entt::registry registry;
-    const entt::entity entity[2]{registry.create(), registry.create()};
+    const entt::entity entity[2]{registry.create(), registry.create()}; // NOLINT
 
     auto group = registry.group(entt::get<int, char>);
     auto cgroup = std::as_const(registry).group_if_exists(entt::get<const int, const char>);
@@ -347,7 +347,7 @@ TEST(NonOwningGroup, IndexRebuiltOnDestroy) {
     registry.emplace<int>(e1, 1);
 
     registry.destroy(e0);
-    registry.emplace<int>(registry.create(), 42);
+    registry.emplace<int>(registry.create(), 42); // NOLINT
 
     ASSERT_EQ(group.size(), 1u);
     ASSERT_EQ(group[{}], e1);
@@ -643,7 +643,7 @@ TEST(NonOwningGroup, ExtendedGet) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
     registry.emplace<char>(entity, 'c');
 
     const auto tup = registry.group(entt::get<int, char>).get(entity);
@@ -754,7 +754,7 @@ TEST(NonOwningGroup, Overlapping) {
     ASSERT_FALSE(group.empty());
     ASSERT_TRUE(other.empty());
 
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
 
     ASSERT_FALSE(group.empty());
     ASSERT_FALSE(other.empty());
@@ -776,7 +776,7 @@ TEST(OwningGroup, Functionalities) {
     registry.emplace<char>(e0, '1');
 
     const auto e1 = registry.create();
-    registry.emplace<int>(e1, 42);
+    registry.emplace<int>(e1, 42); // NOLINT
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
@@ -924,7 +924,7 @@ TEST(OwningGroup, Empty) {
 
 TEST(OwningGroup, Each) {
     entt::registry registry;
-    const entt::entity entity[2]{registry.create(), registry.create()};
+    const entt::entity entity[2]{registry.create(), registry.create()}; // NOLINT
 
     auto group = registry.group<int>(entt::get<char>);
     auto cgroup = std::as_const(registry).group_if_exists<const int>(entt::get<const char>);
@@ -978,16 +978,16 @@ TEST(OwningGroup, SortOrdered) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int, char>();
 
-    entt::entity entity[5]{};
+    entt::entity entity[5]{}; // NOLINT
     registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<test::boxed_int>(entity[0], 12);
+    registry.emplace<test::boxed_int>(entity[0], 12); // NOLINT
     registry.emplace<char>(entity[0], 'a');
 
-    registry.emplace<test::boxed_int>(entity[1], 9);
+    registry.emplace<test::boxed_int>(entity[1], 9); // NOLINT
     registry.emplace<char>(entity[1], 'b');
 
-    registry.emplace<test::boxed_int>(entity[2], 6);
+    registry.emplace<test::boxed_int>(entity[2], 6); // NOLINT
     registry.emplace<char>(entity[2], 'c');
 
     registry.emplace<test::boxed_int>(entity[3], 1);
@@ -1025,16 +1025,16 @@ TEST(OwningGroup, SortReverse) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int, char>();
 
-    entt::entity entity[5]{};
+    entt::entity entity[5]{}; // NOLINT
     registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<test::boxed_int>(entity[0], 6);
+    registry.emplace<test::boxed_int>(entity[0], 6); // NOLINT
     registry.emplace<char>(entity[0], 'a');
 
-    registry.emplace<test::boxed_int>(entity[1], 9);
+    registry.emplace<test::boxed_int>(entity[1], 9); // NOLINT
     registry.emplace<char>(entity[1], 'b');
 
-    registry.emplace<test::boxed_int>(entity[2], 12);
+    registry.emplace<test::boxed_int>(entity[2], 12); // NOLINT
     registry.emplace<char>(entity[2], 'c');
 
     registry.emplace<test::boxed_int>(entity[3], 1);
@@ -1072,10 +1072,10 @@ TEST(OwningGroup, SortUnordered) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int>(entt::get<char>);
 
-    entt::entity entity[7]{};
+    entt::entity entity[7]{}; // NOLINT
     registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<test::boxed_int>(entity[0], 6);
+    registry.emplace<test::boxed_int>(entity[0], 6); // NOLINT
     registry.emplace<char>(entity[0], 'c');
 
     registry.emplace<test::boxed_int>(entity[1], 3);
@@ -1084,14 +1084,14 @@ TEST(OwningGroup, SortUnordered) {
     registry.emplace<test::boxed_int>(entity[2], 1);
     registry.emplace<char>(entity[2], 'a');
 
-    registry.emplace<test::boxed_int>(entity[3], 9);
+    registry.emplace<test::boxed_int>(entity[3], 9); // NOLINT
     registry.emplace<char>(entity[3], 'd');
 
-    registry.emplace<test::boxed_int>(entity[4], 12);
+    registry.emplace<test::boxed_int>(entity[4], 12); // NOLINT
     registry.emplace<char>(entity[4], 'e');
 
-    registry.emplace<test::boxed_int>(entity[5], 4);
-    registry.emplace<test::boxed_int>(entity[6], 5);
+    registry.emplace<test::boxed_int>(entity[5], 4); // NOLINT
+    registry.emplace<test::boxed_int>(entity[6], 5); // NOLINT
 
     group.sort<test::boxed_int, char>([](const auto lhs, const auto rhs) {
         testing::StaticAssertTypeEq<decltype(std::get<0>(lhs)), test::boxed_int &>();
@@ -1129,7 +1129,7 @@ TEST(OwningGroup, SortWithExclusionList) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int>(entt::get<>, entt::exclude<char>);
 
-    entt::entity entity[5]{};
+    entt::entity entity[5]{}; // NOLINT
     registry.create(std::begin(entity), std::end(entity));
 
     registry.emplace<test::boxed_int>(entity[0], 0);
@@ -1176,7 +1176,7 @@ TEST(OwningGroup, IndexRebuiltOnDestroy) {
     registry.emplace<int>(e1, 1);
 
     registry.destroy(e0);
-    registry.emplace<int>(registry.create(), 42);
+    registry.emplace<int>(registry.create(), 42); // NOLINT
 
     ASSERT_EQ(group.size(), 1u);
     ASSERT_EQ(group[{}], e1);
@@ -1476,7 +1476,7 @@ TEST(OwningGroup, SignalRace) {
 TEST(OwningGroup, StableLateInitialization) {
     entt::registry registry;
 
-    for(std::size_t i{}; i < 30u; ++i) {
+    for(std::size_t i{}; i < 30u; ++i) { // NOLINT
         auto entity = registry.create();
         if(!(i % 2u)) registry.emplace<int>(entity);
         if(!(i % 3u)) registry.emplace<char>(entity);
@@ -1532,7 +1532,7 @@ TEST(OwningGroup, ExtendedGet) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
     registry.emplace<char>(entity, 'c');
 
     const auto tup = registry.group<int>(entt::get<char>).get(entity);

test/entt/entity/handle.cpp

@@ -164,7 +164,7 @@ TEST(BasicHandle, Component) {
     ASSERT_EQ('c', handle.emplace_or_replace<char>('c'));
     ASSERT_EQ(.3, handle.emplace_or_replace<double>(.3));
 
-    const auto &patched = handle.patch<int>([](auto &comp) { comp = 42; });
+    const auto &patched = handle.patch<int>([](auto &comp) { comp = 42; }); // NOLINT
 
     ASSERT_EQ(42, patched);
     ASSERT_EQ('a', handle.replace<char>('a'));
@@ -205,7 +205,7 @@ TYPED_TEST(BasicHandle, FromEntity) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
     registry.emplace<char>(entity, 'c');
 
     const handle_type handle{registry, entity};
@@ -243,7 +243,7 @@ TEST(BasicHandle, ImplicitConversions) {
     const entt::handle_view<int, char> handle_view = handle;
     const entt::const_handle_view<int> const_handle_view = handle_view;
 
-    handle.emplace<int>(42);
+    handle.emplace<int>(42); // NOLINT
 
     ASSERT_EQ(handle.get<int>(), const_handle.get<int>());
     ASSERT_EQ(const_handle.get<int>(), handle_view.get<int>());

test/entt/entity/helper.cpp

@@ -93,14 +93,14 @@ TYPED_TEST(ToEntity, Functionalities) {
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(other)), other);
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(next)), next);
 
-    ASSERT_EQ(&registry.get<value_type>(entity) + page_size - (1u + traits_type::in_place_delete), &registry.get<value_type>(other));
+    ASSERT_EQ(&registry.get<value_type>(entity) + page_size - (1u + traits_type::in_place_delete), &registry.get<value_type>(other)); // NOLINT
 
     registry.destroy(other);
 
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(entity)), entity);
     ASSERT_EQ(entt::to_entity(storage, registry.get<value_type>(next)), next);
 
-    ASSERT_EQ(&registry.get<value_type>(entity) + page_size - 1u, &registry.get<value_type>(next));
+    ASSERT_EQ(&registry.get<value_type>(entity) + page_size - 1u, &registry.get<value_type>(next)); // NOLINT
 
     ASSERT_EQ(entt::to_entity(storage, value_type{42}), null);
     ASSERT_EQ(entt::to_entity(storage, value), null);

test/entt/entity/organizer.cpp

@@ -397,7 +397,7 @@ TEST(Organizer, Dependencies) {
     organizer.emplace<char, const double>(+[](const void *, entt::registry &) {});
 
     const auto graph = organizer.graph();
-    std::array<const entt::type_info *, 5u> buffer{};
+    std::array<const entt::type_info *, 5u> buffer{}; // NOLINT
 
     ASSERT_EQ(graph.size(), 3u);
 
@@ -439,7 +439,7 @@ TEST(Organizer, ToArgsIntegrity) {
     entt::registry registry;
 
     organizer.emplace<&to_args_integrity>();
-    registry.ctx().emplace<std::size_t>(42u);
+    registry.ctx().emplace<std::size_t>(42u); // NOLINT
 
     auto graph = organizer.graph();
     graph[0u].callback()(graph[0u].data(), registry);

test/entt/entity/registry.cpp

@@ -121,7 +121,7 @@ TEST(Registry, Context) {
     ASSERT_TRUE(ctx.erase<char>());
 
     ctx.emplace<char>('c');
-    ctx.emplace<int>(42);
+    ctx.emplace<int>(42); // NOLINT
 
     ASSERT_EQ(ctx.emplace<char>('a'), 'c');
     ASSERT_EQ(ctx.find<const char>(), cctx.find<char>());
@@ -154,7 +154,7 @@ TEST(Registry, ContextHint) {
     auto &ctx = registry.ctx();
     const auto &cctx = std::as_const(registry).ctx();
 
-    ctx.emplace<int>(42);
+    ctx.emplace<int>(42); // NOLINT
     ctx.emplace_as<int>("other"_hs, 3);
 
     ASSERT_TRUE(ctx.contains<int>());
@@ -169,7 +169,7 @@ TEST(Registry, ContextHint) {
     ASSERT_EQ(cctx.get<const int>("other"_hs), 3);
 
     ctx.insert_or_assign(3);
-    ctx.insert_or_assign("other"_hs, 42);
+    ctx.insert_or_assign("other"_hs, 42); // NOLINT
 
     ASSERT_EQ(ctx.get<const int>(), 3);
     ASSERT_EQ(cctx.get<int>("other"_hs), 42);
@@ -198,7 +198,7 @@ TEST(Registry, ContextAsRef) {
     ASSERT_EQ(registry.ctx().get<const int>(), 3);
     ASSERT_EQ(registry.ctx().get<int>(), 3);
 
-    registry.ctx().get<int>() = 42;
+    registry.ctx().get<int>() = 42; // NOLINT
 
     ASSERT_EQ(registry.ctx().get<int>(), 42);
     ASSERT_EQ(value, 42);
@@ -377,7 +377,7 @@ TEST(Registry, Functionalities) {
 
 TEST(Registry, Constructors) {
     entt::registry registry;
-    entt::registry other{42u};
+    entt::registry other{42u}; // NOLINT
 
     ASSERT_TRUE(registry.storage<entt::entity>().empty());
     ASSERT_TRUE(other.storage<entt::entity>().empty());
@@ -450,7 +450,7 @@ TEST(Registry, ReplaceAggregate) {
     const auto entity = registry.create();
 
     registry.emplace<test::aggregate>(entity, 0);
-    auto &instance = registry.replace<test::aggregate>(entity, 42);
+    auto &instance = registry.replace<test::aggregate>(entity, 42); // NOLINT
 
     ASSERT_EQ(instance.value, 42);
 }
@@ -458,7 +458,7 @@ TEST(Registry, ReplaceAggregate) {
 TEST(Registry, EmplaceOrReplaceAggregate) {
     entt::registry registry;
     const auto entity = registry.create();
-    auto &instance = registry.emplace_or_replace<test::aggregate>(entity, 42);
+    auto &instance = registry.emplace_or_replace<test::aggregate>(entity, 42); // NOLINT
 
     ASSERT_EQ(instance.value, 42);
 }
@@ -490,7 +490,7 @@ TEST(Registry, CreateManyEntitiesAtOnce) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry;
-    entt::entity entity[3];
+    entt::entity entity[3]; // NOLINT
 
     const auto entt = registry.create();
     registry.destroy(registry.create());
@@ -515,12 +515,12 @@ TEST(Registry, CreateManyEntitiesAtOnce) {
 
 TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
     entt::registry registry;
-    entt::entity entity[3];
+    entt::entity entity[3]; // NOLINT
     listener listener;
 
     registry.on_construct<int>().connect<&listener::incr>(listener);
     registry.create(std::begin(entity), std::end(entity));
-    registry.insert(std::begin(entity), std::end(entity), 42);
+    registry.insert(std::begin(entity), std::end(entity), 42); // NOLINT
     registry.insert(std::begin(entity), std::end(entity), 'c');
 
     ASSERT_EQ(registry.get<int>(entity[0]), 42);
@@ -578,14 +578,14 @@ TEST(Registry, CreateClearCycle) {
     entt::registry registry;
     entt::entity pre{}, post{};
 
-    for(int i = 0; i < 10; ++i) {
+    for(int i = 0; i < 10; ++i) { // NOLINT
         const auto entity = registry.create();
         registry.emplace<double>(entity);
     }
 
     registry.clear();
 
-    for(int i = 0; i < 7; ++i) {
+    for(int i = 0; i < 7; ++i) { // NOLINT
         const auto entity = registry.create();
         registry.emplace<int>(entity);
 
@@ -596,7 +596,7 @@ TEST(Registry, CreateClearCycle) {
 
     registry.clear();
 
-    for(int i = 0; i < 5; ++i) {
+    for(int i = 0; i < 5; ++i) { // NOLINT
         const auto entity = registry.create();
 
         if(i == 3) {
@@ -664,7 +664,7 @@ TEST(Registry, DestroyRange) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -740,7 +740,7 @@ TEST(Registry, StableDestroy) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -822,7 +822,7 @@ TEST(Registry, TombstoneVersion) {
 
 TEST(Registry, Orphans) {
     entt::registry registry;
-    entt::entity entity[3u]{};
+    entt::entity entity[3u]{}; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.emplace<int>(entity[0u]);
@@ -842,7 +842,7 @@ TEST(Registry, Orphans) {
 
 TEST(Registry, View) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     auto iview = registry.view<int>();
     auto cview = registry.view<char>();
@@ -876,19 +876,19 @@ TEST(Registry, View) {
     ASSERT_EQ(std::distance(mview.begin(), mview.end()), 2);
     ASSERT_EQ(std::distance(fview.begin(), fview.end()), 1);
 
-    mview.each([&entity, first = true](auto entt, auto &&...) mutable {
-        ASSERT_EQ(entt, entity[2u * first]); // NOLINT
+    mview.each([&entity, first = true](auto entt, auto &&...) mutable { // NOLINT
+        ASSERT_EQ(entt, entity[2u * first]);                            // NOLINT
         first = false;
     });
 
-    fview.each([&entity](auto entt, auto &&...) {
+    fview.each([&entity](auto entt, auto &&...) { // NOLINT
         ASSERT_EQ(entt, entity[1u]);
     });
 }
 
 TEST(Registry, ExcludeOnlyView) {
     entt::registry registry;
-    entt::entity entity[4u];
+    entt::entity entity[4u]; // NOLINT
 
     auto view = registry.view<entt::entity>(entt::exclude<int>);
 
@@ -910,14 +910,14 @@ TEST(Registry, ExcludeOnlyView) {
         ASSERT_EQ(entt, entity[1u]);
     }
 
-    view.each([&entity](auto entt) {
+    view.each([&entity](auto entt) { // NOLINT
         ASSERT_EQ(entt, entity[1u]);
     });
 }
 
 TEST(Registry, NonOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<int>(std::begin(entity), std::end(entity), 0);
@@ -934,7 +934,7 @@ TEST(Registry, NonOwningGroupInitOnFirstUse) {
 
 TEST(Registry, NonOwningGroupInitOnEmplace) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
     auto group = registry.group(entt::get<int, char>);
 
     registry.create(std::begin(entity), std::end(entity));
@@ -951,7 +951,7 @@ TEST(Registry, NonOwningGroupInitOnEmplace) {
 
 TEST(Registry, FullOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<int>(std::begin(entity), std::end(entity), 0);
@@ -970,7 +970,7 @@ TEST(Registry, FullOwningGroupInitOnFirstUse) {
 
 TEST(Registry, FullOwningGroupInitOnEmplace) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
     auto group = registry.group<int, char>();
 
     registry.create(std::begin(entity), std::end(entity));
@@ -989,7 +989,7 @@ TEST(Registry, FullOwningGroupInitOnEmplace) {
 
 TEST(Registry, PartialOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<int>(std::begin(entity), std::end(entity), 0);
@@ -1008,7 +1008,7 @@ TEST(Registry, PartialOwningGroupInitOnFirstUse) {
 
 TEST(Registry, PartialOwningGroupInitOnEmplace) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
     auto group = registry.group<int>(entt::get<char>);
 
     registry.create(std::begin(entity), std::end(entity));
@@ -1238,7 +1238,7 @@ TEST(Registry, ComponentsWithTypesFromStandardTemplateLibrary) {
     // see #37 - the test shouldn't crash, that's all
     entt::registry registry;
     const auto entity = registry.create();
-    registry.emplace<std::unordered_set<int>>(entity).insert(42);
+    registry.emplace<std::unordered_set<int>>(entity).insert(42); // NOLINT
     registry.destroy(entity);
 }
 
@@ -1251,7 +1251,7 @@ TEST(Registry, ConstructWithComponents) {
 
 TEST(Registry, Signals) {
     entt::registry registry;
-    entt::entity entity[2u];
+    entt::entity entity[2u]; // NOLINT
     listener listener;
 
     registry.on_construct<test::empty>().connect<&listener::incr>(listener);
@@ -1453,7 +1453,7 @@ TEST(Registry, SignalWhenDestroying) {
 
 TEST(Registry, Insert) {
     entt::registry registry;
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1478,10 +1478,10 @@ TEST(Registry, Insert) {
     ASSERT_FALSE(registry.all_of<float>(entity[2u]));
 
     registry.clear<float>();
-    float value[3]{0.f, 1.f, 2.f};
+    float value[3]{0.f, 1.f, 2.f}; // NOLINT
 
     const auto iview = registry.view<int>();
-    registry.insert<float>(iview.rbegin(), iview.rend(), value);
+    registry.insert<float>(iview.rbegin(), iview.rend(), value); // NOLINT
 
     ASSERT_EQ(registry.get<float>(entity[0u]), 0.f);
     ASSERT_EQ(registry.get<float>(entity[1u]), 1.f);
@@ -1492,7 +1492,7 @@ TEST(Registry, Erase) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1529,8 +1529,8 @@ TEST(Registry, Erase) {
     ASSERT_EQ(registry.storage<char>().size(), 0u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 
-    registry.insert<int>(std::begin(entity) + 1, std::end(entity) - 1u);
-    registry.insert<char>(std::begin(entity) + 1, std::end(entity) - 1u);
+    registry.insert<int>(std::begin(entity) + 1, std::end(entity) - 1u);  // NOLINT
+    registry.insert<char>(std::begin(entity) + 1, std::end(entity) - 1u); // NOLINT
 
     ASSERT_EQ(registry.storage<int>().size(), 1u);
     ASSERT_EQ(registry.storage<char>().size(), 1u);
@@ -1558,7 +1558,7 @@ TEST(Registry, Erase) {
 
 ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
     entt::registry registry;
-    const entt::entity entity[1u]{registry.create()};
+    const entt::entity entity[1u]{registry.create()}; // NOLINT
 
     ASSERT_FALSE((registry.any_of<int>(entity[0u])));
     ASSERT_DEATH((registry.erase<int>(std::begin(entity), std::end(entity))), "");
@@ -1569,7 +1569,7 @@ TEST(Registry, StableErase) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1644,7 +1644,7 @@ TEST(Registry, Remove) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1686,8 +1686,8 @@ TEST(Registry, Remove) {
     ASSERT_EQ(registry.storage<char>().size(), 0u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 
-    registry.insert<int>(std::begin(entity) + 1, std::end(entity) - 1u);
-    registry.insert<char>(std::begin(entity) + 1, std::end(entity) - 1u);
+    registry.insert<int>(std::begin(entity) + 1, std::end(entity) - 1u);  // NOLINT
+    registry.insert<char>(std::begin(entity) + 1, std::end(entity) - 1u); // NOLINT
 
     ASSERT_EQ(registry.storage<int>().size(), 1u);
     ASSERT_EQ(registry.storage<char>().size(), 1u);
@@ -1719,7 +1719,7 @@ TEST(Registry, StableRemove) {
     entt::registry registry;
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1763,7 +1763,7 @@ TEST(Registry, StableRemove) {
 
 TEST(Registry, Compact) {
     entt::registry registry;
-    entt::entity entity[2u];
+    entt::entity entity[2u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
 
@@ -1958,7 +1958,7 @@ TEST(Registry, MoveOnlyComponent) {
 TEST(Registry, NonDefaultConstructibleComponent) {
     entt::registry registry;
     // the purpose is to ensure that non default constructible type are always accepted
-    registry.emplace<test::non_default_constructible>(registry.create(), 42);
+    registry.emplace<test::non_default_constructible>(registry.create(), 42); // NOLINT
 }
 
 TEST(Registry, Dependencies) {
@@ -2005,7 +2005,7 @@ TEST(Registry, AssignEntities) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry;
-    entt::entity entity[3];
+    entt::entity entity[3]; // NOLINT
     registry.create(std::begin(entity), std::end(entity));
     registry.destroy(entity[1]);
     registry.destroy(entity[2]);
@@ -2275,7 +2275,7 @@ TEST(Registry, NoEtoType) {
     const auto entity = registry.create();
 
     registry.emplace<no_eto_type>(entity);
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
 
     ASSERT_NE(registry.storage<no_eto_type>().raw(), nullptr);
     ASSERT_NE(registry.try_get<no_eto_type>(entity), nullptr);

test/entt/entity/runtime_view.cpp

@@ -59,7 +59,7 @@ TYPED_TEST(RuntimeView, Functionalities) {
 
     registry.get<char>(e0) = '1';
     registry.get<char>(e1) = '2';
-    registry.get<int>(e1) = 42;
+    registry.get<int>(e1) = 42; // NOLINT
 
     for(auto entity: view) {
         ASSERT_EQ(registry.get<int>(entity), 42);
@@ -375,7 +375,7 @@ TYPED_TEST(RuntimeView, StableTypeWithExcludedComponent) {
     const auto other = registry.create();
 
     registry.emplace<test::pointer_stable>(entity, 0);
-    registry.emplace<test::pointer_stable>(other, 42);
+    registry.emplace<test::pointer_stable>(other, 42); // NOLINT
     registry.emplace<int>(entity);
 
     view.iterate(registry.storage<test::pointer_stable>()).exclude(registry.storage<int>());

test/entt/entity/sigh_mixin.cpp

@@ -39,7 +39,7 @@ using SighMixinTypes = ::testing::Types<int, test::pointer_stable>;
 TYPED_TEST_SUITE(SighMixin, SighMixinTypes, );
 
 TEST(SighMixin, GenericType) {
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
     entt::sigh_mixin<entt::storage<int>> pool;
     entt::registry registry;
 
@@ -50,7 +50,7 @@ TEST(SighMixin, GenericType) {
 
     ASSERT_EQ(pool.size(), 0u);
 
-    pool.insert(entity, entity + 1u);
+    pool.insert(entity, entity + 1u); // NOLINT
     pool.erase(entity[0u]);
 
     ASSERT_EQ(pool.size(), 0u);
@@ -113,7 +113,7 @@ TEST(SighMixin, GenericType) {
 }
 
 TEST(SighMixin, StableType) {
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
     entt::sigh_mixin<entt::storage<test::pointer_stable>> pool;
     entt::registry registry;
 
@@ -176,7 +176,7 @@ TEST(SighMixin, StableType) {
 }
 
 TEST(SighMixin, NonDefaultConstructibleType) {
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
     entt::sigh_mixin<entt::storage<test::non_default_constructible>> pool;
     entt::registry registry;
 
@@ -237,7 +237,7 @@ TEST(SighMixin, VoidType) {
     pool.on_construct().connect<&listener<entt::registry>>(on_construct);
     pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
 
-    pool.emplace(entt::entity{99});
+    pool.emplace(entt::entity{99}); // NOLINT
 
     ASSERT_EQ(pool.type(), entt::type_id<void>());
     ASSERT_TRUE(pool.contains(entt::entity{99}));
@@ -308,8 +308,8 @@ TEST(SighMixin, StorageEntity) {
     pool.emplace();
     pool.emplace(entt::entity{0});
 
-    entt::entity entity[1u]{};
-    pool.insert(entity, entity + 1u);
+    entt::entity entity[1u]{};        // NOLINT
+    pool.insert(entity, entity + 1u); // NOLINT
 
     ASSERT_EQ(on_construct, 6u);
     ASSERT_EQ(on_destroy, 3u);
@@ -362,7 +362,7 @@ TYPED_TEST(SighMixin, Move) {
     other = entt::sigh_mixin<entt::storage<value_type>>{};
     other.bind(entt::forward_as_any(registry));
 
-    other.emplace(entt::entity{42}, 42);
+    other.emplace(entt::entity{42}, 42); // NOLINT
     other = std::move(pool);
 
     ASSERT_TRUE(pool.empty()); // NOLINT
@@ -395,11 +395,11 @@ TYPED_TEST(SighMixin, Swap) {
     other.on_construct().template connect<&listener<entt::registry>>(on_construct);
     other.on_destroy().template connect<&listener<entt::registry>>(on_destroy);
 
-    pool.emplace(entt::entity{42}, 41);
+    pool.emplace(entt::entity{42}, 41); // NOLINT
 
-    other.emplace(entt::entity{9}, 8);
+    other.emplace(entt::entity{9}, 8); // NOLINT
     other.emplace(entt::entity{3}, 2);
-    other.erase(entt::entity{9});
+    other.erase(entt::entity{9}); // NOLINT
 
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(other.size(), 1u + traits_type::in_place_delete);
@@ -438,7 +438,7 @@ TYPED_TEST(SighMixin, CustomRegistry) {
     pool.on_destroy().template connect<&listener<custom_registry>>(on_destroy);
 
     pool.emplace(test::custom_entity{3});
-    pool.emplace(test::custom_entity{42});
+    pool.emplace(test::custom_entity{42}); // NOLINT
 
     ASSERT_EQ(on_construct, 2u);
     ASSERT_EQ(on_destroy, 0u);
@@ -557,7 +557,7 @@ TYPED_TEST(SighMixin, ThrowingAllocator) {
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entt::entity{0}, 0);
-    const entt::entity entity[2u]{entt::entity{1}, entt::entity{sparse_page_size}};
+    const entt::entity entity[2u]{entt::entity{1}, entt::entity{sparse_page_size}}; // NOLINT
     pool.get_allocator().template throw_counter<entt::entity>(1u);
 
     ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), value_type{0}), test::throwing_allocator_exception);
@@ -565,7 +565,7 @@ TYPED_TEST(SighMixin, ThrowingAllocator) {
     ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
     pool.erase(entt::entity{1});
-    const value_type components[2u]{value_type{1}, value_type{sparse_page_size}};
+    const value_type components[2u]{value_type{1}, value_type{sparse_page_size}}; // NOLINT
     pool.get_allocator().template throw_counter<entt::entity>(0u);
     pool.compact();
 
@@ -589,8 +589,8 @@ TEST(SighMixin, ThrowingComponent) {
     pool.on_construct().connect<&listener<registry_type>>(on_construct);
     pool.on_destroy().connect<&listener<registry_type>>(on_destroy);
 
-    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}};
-    const test::throwing_type value[2u]{true, false};
+    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}}; // NOLINT
+    const test::throwing_type value[2u]{true, false};                 // NOLINT
 
     // strong exception safety
     ASSERT_THROW(pool.emplace(entity[0u], value[0u]), test::throwing_type_exception);

test/entt/entity/snapshot.cpp

@@ -55,7 +55,7 @@ TEST(BasicSnapshot, GetEntityType) {
     ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(&data[1u]), nullptr);
     ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[1u]), storage.free_list());
 
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.destroy(entity[1u]);
@@ -89,8 +89,8 @@ TEST(BasicSnapshot, GetType) {
     const entt::basic_snapshot snapshot{registry};
     const auto &storage = registry.storage<int>();
 
-    entt::entity entity[3u];
-    const int values[3u]{1, 2, 3};
+    entt::entity entity[3u];       // NOLINT
+    const int values[3u]{1, 2, 3}; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<int>(std::begin(entity), std::end(entity), std::begin(values));
@@ -135,7 +135,7 @@ TEST(BasicSnapshot, GetEmptyType) {
     const entt::basic_snapshot snapshot{registry};
     const auto &storage = registry.storage<test::empty>();
 
-    entt::entity entity[3u];
+    entt::entity entity[3u]; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<test::empty>(std::begin(entity), std::end(entity));
@@ -173,8 +173,8 @@ TEST(BasicSnapshot, GetTypeSparse) {
     entt::registry registry;
     const entt::basic_snapshot snapshot{registry};
 
-    entt::entity entity[3u];
-    const int values[3u]{1, 2, 3};
+    entt::entity entity[3u];       // NOLINT
+    const int values[3u]{1, 2, 3}; // NOLINT
 
     registry.create(std::begin(entity), std::end(entity));
     registry.insert<int>(std::begin(entity), std::end(entity), std::begin(values));
@@ -245,7 +245,7 @@ TEST(BasicSnapshotLoader, GetEntityType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[3u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u), traits_type::construct(1u, 1u)};
+    const entt::entity entity[3u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u), traits_type::construct(1u, 1u)}; // NOLINT
 
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
@@ -296,8 +296,8 @@ TEST(BasicSnapshotLoader, GetType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
-    const int values[2u]{1, 3};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
+    const int values[2u]{1, 3};                                                                    // NOLINT
 
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
@@ -344,7 +344,7 @@ TEST(BasicSnapshotLoader, GetEmptyType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
 
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
@@ -385,8 +385,8 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
-    const int values[2u]{1, 3};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
+    const int values[2u]{1, 3};                                                                    // NOLINT
 
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
@@ -462,7 +462,7 @@ TEST(BasicSnapshotLoader, Orphans) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
     const int value = 42;
 
     ASSERT_FALSE(registry.valid(entity[0u]));
@@ -514,7 +514,7 @@ TEST(BasicContinuousLoader, GetEntityType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[3u]{traits_type::construct(1u, 0u), traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const entt::entity entity[3u]{traits_type::construct(1u, 0u), traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
 
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
@@ -649,8 +649,8 @@ TEST(BasicContinuousLoader, GetType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
-    const int values[2u]{1, 3};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
+    const int values[2u]{1, 3};                                                                    // NOLINT
 
     ASSERT_FALSE(loader.contains(entity[0u]));
     ASSERT_FALSE(loader.contains(entity[1u]));
@@ -705,7 +705,7 @@ TEST(BasicContinuousLoader, GetTypeExtended) {
     const auto &storage = registry.storage<shadow>();
 
     std::vector<entt::any> data{};
-    const entt::entity entity[2u]{traits_type::construct(0u, 1u), traits_type::construct(1u, 1u)};
+    const entt::entity entity[2u]{traits_type::construct(0u, 1u), traits_type::construct(1u, 1u)}; // NOLINT
     const shadow value{entity[0u]};
 
     auto archive = [&loader, &data, pos = 0u](auto &elem) mutable {
@@ -759,7 +759,7 @@ TEST(BasicContinuousLoader, GetEmptyType) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
 
     ASSERT_FALSE(loader.contains(entity[0u]));
     ASSERT_FALSE(loader.contains(entity[1u]));
@@ -809,8 +809,8 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
-    const int values[2u]{1, 3};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
+    const int values[2u]{1, 3};                                                                    // NOLINT
 
     ASSERT_FALSE(loader.contains(entity[0u]));
     ASSERT_FALSE(loader.contains(entity[1u]));
@@ -895,7 +895,7 @@ TEST(BasicContinuousLoader, Orphans) {
 
     std::vector<entt::any> data{};
     auto archive = [&data, pos = 0u](auto &elem) mutable { elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]); };
-    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const entt::entity entity[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)}; // NOLINT
     const int value = 42;
 
     ASSERT_FALSE(registry.valid(entity[0u]));

test/entt/entity/sparse_set.cpp

@@ -87,7 +87,7 @@ TYPED_TEST(SparseSet, Move) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        set.push(entity_type{42});
+        set.push(entity_type{42}); // NOLINT
 
         static_assert(std::is_move_constructible_v<decltype(set)>, "Move constructible type required");
         static_assert(std::is_move_assignable_v<decltype(set)>, "Move assignable type required");
@@ -100,7 +100,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(set.policy(), policy); // NOLINT
         ASSERT_EQ(other.policy(), policy);
 
-        ASSERT_EQ(other.index(entity_type{42}), 0u);
+        ASSERT_EQ(other.index(entity_type{42}), 0u); // NOLINT
 
         sparse_set_type extended{std::move(other), allocator_type{}};
 
@@ -110,7 +110,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(other.policy(), policy); // NOLINT
         ASSERT_EQ(extended.policy(), policy);
 
-        ASSERT_EQ(extended.index(entity_type{42}), 0u);
+        ASSERT_EQ(extended.index(entity_type{42}), 0u); // NOLINT
 
         set = std::move(extended);
 
@@ -122,10 +122,10 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(other.policy(), policy);    // NOLINT
         ASSERT_EQ(extended.policy(), policy); // NOLINT
 
-        ASSERT_EQ(set.index(entity_type{42}), 0u);
+        ASSERT_EQ(set.index(entity_type{42}), 0u); // NOLINT
 
         other = sparse_set_type{policy};
-        other.push(entity_type{3});
+        other.push(entity_type{3}); // NOLINT
         other = std::move(set);
 
         ASSERT_TRUE(set.empty()); // NOLINT
@@ -134,7 +134,7 @@ TYPED_TEST(SparseSet, Move) {
         ASSERT_EQ(set.policy(), policy); // NOLINT
         ASSERT_EQ(other.policy(), policy);
 
-        ASSERT_EQ(other.index(entity_type{42}), 0u);
+        ASSERT_EQ(other.index(entity_type{42}), 0u); // NOLINT
     }
 }
 
@@ -149,11 +149,11 @@ TYPED_TEST(SparseSet, Swap) {
         ASSERT_EQ(set.policy(), policy);
         ASSERT_EQ(other.policy(), entt::deletion_policy::in_place);
 
-        set.push(entity_type{42});
+        set.push(entity_type{42}); // NOLINT
 
-        other.push(entity_type{9});
-        other.push(entity_type{3});
-        other.erase(entity_type{9});
+        other.push(entity_type{9});  // NOLINT
+        other.push(entity_type{3});  // NOLINT
+        other.erase(entity_type{9}); // NOLINT
 
         ASSERT_EQ(set.size(), 1u);
         ASSERT_EQ(other.size(), 2u);
@@ -166,8 +166,8 @@ TYPED_TEST(SparseSet, Swap) {
         ASSERT_EQ(set.size(), 2u);
         ASSERT_EQ(other.size(), 1u);
 
-        ASSERT_EQ(set.index(entity_type{3}), 1u);
-        ASSERT_EQ(other.index(entity_type{42}), 0u);
+        ASSERT_EQ(set.index(entity_type{3}), 1u);    // NOLINT
+        ASSERT_EQ(other.index(entity_type{42}), 0u); // NOLINT
     }
 }
 
@@ -179,8 +179,8 @@ TYPED_TEST(SparseSet, FreeList) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{42};
-        const entity_type other{3};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         switch(policy) {
         case entt::deletion_policy::swap_and_pop: {
@@ -252,7 +252,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, FreeList) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        set.push(entity_type{3});
+        set.push(entity_type{3}); // NOLINT
 
         switch(policy) {
         case entt::deletion_policy::swap_and_pop:
@@ -274,14 +274,14 @@ TYPED_TEST(SparseSet, Capacity) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        set.reserve(42);
+        set.reserve(64);
 
-        ASSERT_EQ(set.capacity(), 42u);
+        ASSERT_EQ(set.capacity(), 64u);
         ASSERT_TRUE(set.empty());
 
         set.reserve(0);
 
-        ASSERT_EQ(set.capacity(), 42u);
+        ASSERT_EQ(set.capacity(), 64u);
         ASSERT_TRUE(set.empty());
     }
 }
@@ -296,30 +296,30 @@ TYPED_TEST(SparseSet, Pagination) {
 
         ASSERT_EQ(set.extent(), 0u);
 
-        set.push(entity_type{traits_type::page_size - 1u});
+        set.push(entity_type{traits_type::page_size - 1u}); // NOLINT
 
         ASSERT_EQ(set.extent(), traits_type::page_size);
-        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size - 1u}));
+        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size - 1u})); // NOLINT
 
-        set.push(entity_type{traits_type::page_size});
+        set.push(entity_type{traits_type::page_size}); // NOLINT
 
         ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
-        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size - 1u}));
-        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size}));
-        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size + 1u}));
+        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size - 1u}));  // NOLINT
+        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size}));       // NOLINT
+        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size + 1u})); // NOLINT
 
-        set.erase(entity_type{traits_type::page_size - 1u});
+        set.erase(entity_type{traits_type::page_size - 1u}); // NOLINT
 
         ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
-        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u}));
-        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size}));
+        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u})); // NOLINT
+        ASSERT_TRUE(set.contains(entity_type{traits_type::page_size}));       // NOLINT
 
         set.shrink_to_fit();
-        set.erase(entity_type{traits_type::page_size});
+        set.erase(entity_type{traits_type::page_size}); // NOLINT
 
         ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
-        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u}));
-        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size}));
+        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u})); // NOLINT
+        ASSERT_FALSE(set.contains(entity_type{traits_type::page_size}));      // NOLINT
 
         set.shrink_to_fit();
 
@@ -334,8 +334,8 @@ TYPED_TEST(SparseSet, Contiguous) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{42};
-        const entity_type other{3};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         ASSERT_TRUE(set.contiguous());
 
@@ -389,8 +389,8 @@ TYPED_TEST(SparseSet, Data) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
-        const entity_type other{42};
+        const entity_type entity{3}; // NOLINT
+        const entity_type other{42}; // NOLINT
 
         ASSERT_EQ(set.data(), nullptr);
 
@@ -457,7 +457,7 @@ TYPED_TEST(SparseSet, Iterator) {
         testing::StaticAssertTypeEq<typename iterator::pointer, const entity_type *>();
         testing::StaticAssertTypeEq<typename iterator::reference, const entity_type &>();
 
-        set.push(entity_type{3});
+        set.push(entity_type{3}); // NOLINT
 
         iterator end{set.begin()};
         iterator begin{};
@@ -504,20 +504,20 @@ TYPED_TEST(SparseSet, Iterator) {
         ASSERT_GT(end, begin);
         ASSERT_GE(end, set.end());
 
-        ASSERT_EQ(*begin, entity_type{3});
-        ASSERT_EQ(*begin.operator->(), entity_type{3});
+        ASSERT_EQ(*begin, entity_type{3});              // NOLINT
+        ASSERT_EQ(*begin.operator->(), entity_type{3}); // NOLINT
 
         ASSERT_EQ(begin.index(), 0);
         ASSERT_EQ(end.index(), -1);
 
-        set.push(entity_type{42});
+        set.push(entity_type{42}); // NOLINT
         begin = set.begin();
 
         ASSERT_EQ(begin.index(), 1);
         ASSERT_EQ(end.index(), -1);
 
-        ASSERT_EQ(begin[0u], entity_type{42});
-        ASSERT_EQ(begin[1u], entity_type{3});
+        ASSERT_EQ(begin[0u], entity_type{42}); // NOLINT
+        ASSERT_EQ(begin[1u], entity_type{3});  // NOLINT
     }
 }
 
@@ -533,7 +533,7 @@ TYPED_TEST(SparseSet, ReverseIterator) {
         testing::StaticAssertTypeEq<typename reverse_iterator::pointer, const entity_type *>();
         testing::StaticAssertTypeEq<typename reverse_iterator::reference, const entity_type &>();
 
-        set.push(entity_type{3});
+        set.push(entity_type{3}); // NOLINT
 
         reverse_iterator end{set.rbegin()};
         reverse_iterator begin{};
@@ -573,20 +573,20 @@ TYPED_TEST(SparseSet, ReverseIterator) {
         ASSERT_GT(end, begin);
         ASSERT_GE(end, set.rend());
 
-        ASSERT_EQ(*begin, entity_type{3});
-        ASSERT_EQ(*begin.operator->(), entity_type{3});
+        ASSERT_EQ(*begin, entity_type{3});              // NOLINT
+        ASSERT_EQ(*begin.operator->(), entity_type{3}); // NOLINT
 
         ASSERT_EQ(begin.base().index(), -1);
         ASSERT_EQ(end.base().index(), 0);
 
-        set.push(entity_type{42});
+        set.push(entity_type{42}); // NOLINT
         end = set.rend();
 
         ASSERT_EQ(begin.base().index(), -1);
         ASSERT_EQ(end.base().index(), 1);
 
-        ASSERT_EQ(begin[0u], entity_type{3});
-        ASSERT_EQ(begin[1u], entity_type{42});
+        ASSERT_EQ(begin[0u], entity_type{3});  // NOLINT
+        ASSERT_EQ(begin[1u], entity_type{42}); // NOLINT
     }
 }
 
@@ -597,8 +597,8 @@ TYPED_TEST(SparseSet, ScopedIterator) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
-        const entity_type other{42};
+        const entity_type entity{3}; // NOLINT
+        const entity_type other{42}; // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -641,8 +641,8 @@ TYPED_TEST(SparseSet, ScopedReverseIterator) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
-        const entity_type other{42};
+        const entity_type entity{3}; // NOLINT
+        const entity_type other{42}; // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -689,8 +689,8 @@ TYPED_TEST(SparseSet, Find) {
         ASSERT_EQ(set.find(entt::tombstone), set.cend());
         ASSERT_EQ(set.find(entt::null), set.cend());
 
-        const entity_type entity{3};
-        const entity_type other{traits_type::construct(99, 1)};
+        const entity_type entity{3};                            // NOLINT
+        const entity_type other{traits_type::construct(99, 1)}; // NOLINT
 
         ASSERT_EQ(set.find(entity), set.cend());
         ASSERT_EQ(set.find(other), set.cend());
@@ -712,7 +712,7 @@ TYPED_TEST(SparseSet, FindErased) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
+        const entity_type entity{3}; // NOLINT
 
         set.push(entity);
         set.erase(entity);
@@ -739,8 +739,8 @@ TYPED_TEST(SparseSet, Contains) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
-        const entity_type other{traits_type::construct(99, 1)};
+        const entity_type entity{3};                            // NOLINT
+        const entity_type other{traits_type::construct(99, 1)}; // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -751,9 +751,9 @@ TYPED_TEST(SparseSet, Contains) {
         ASSERT_TRUE(set.contains(entity));
         ASSERT_TRUE(set.contains(other));
 
-        ASSERT_FALSE(set.contains(entity_type{1}));
-        ASSERT_FALSE(set.contains(traits_type::construct(3, 1)));
-        ASSERT_FALSE(set.contains(traits_type::construct(99, traits_type::to_version(entt::tombstone))));
+        ASSERT_FALSE(set.contains(entity_type{1}));                                                       // NOLINT
+        ASSERT_FALSE(set.contains(traits_type::construct(3, 1)));                                         // NOLINT
+        ASSERT_FALSE(set.contains(traits_type::construct(99, traits_type::to_version(entt::tombstone)))); // NOLINT
 
         set.erase(entity);
         set.remove(other);
@@ -801,7 +801,7 @@ TYPED_TEST(SparseSet, ContainsErased) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
+        const entity_type entity{3}; // NOLINT
 
         set.push(entity);
         set.erase(entity);
@@ -837,8 +837,8 @@ TYPED_TEST(SparseSet, Current) {
         ASSERT_EQ(set.current(entt::tombstone), traits_type::to_version(entt::tombstone));
         ASSERT_EQ(set.current(entt::null), traits_type::to_version(entt::tombstone));
 
-        const entity_type entity{traits_type::construct(0, 0)};
-        const entity_type other{traits_type::construct(3, 3)};
+        const entity_type entity{traits_type::construct(0, 0)}; // NOLINT
+        const entity_type other{traits_type::construct(3, 3)};  // NOLINT
 
         ASSERT_EQ(set.current(entity), traits_type::to_version(entt::tombstone));
         ASSERT_EQ(set.current(other), traits_type::to_version(entt::tombstone));
@@ -862,7 +862,7 @@ TYPED_TEST(SparseSet, CurrentErased) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{traits_type::construct(3, 3)};
+        const entity_type entity{traits_type::construct(3, 3)}; // NOLINT
 
         set.push(entity);
         set.erase(entity);
@@ -892,8 +892,8 @@ TYPED_TEST(SparseSet, Index) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{42};
-        const entity_type other{3};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -956,8 +956,8 @@ TYPED_TEST(SparseSet, Indexing) {
         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};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -1003,7 +1003,7 @@ TYPED_TEST(SparseSet, Value) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
+        const entity_type entity{3}; // NOLINT
 
         set.push(entity);
 
@@ -1022,7 +1022,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Value) {
         // value works the same in all cases, test only once
         switch(policy) {
         case entt::deletion_policy::swap_and_pop:
-            ASSERT_DEATH([[maybe_unused]] auto *value = set.value(entity_type{3}), "");
+            ASSERT_DEATH([[maybe_unused]] auto *value = set.value(entity_type{3}), ""); // NOLINT
             break;
         case entt::deletion_policy::in_place:
         case entt::deletion_policy::swap_only:
@@ -1039,7 +1039,7 @@ TYPED_TEST(SparseSet, Push) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity[2u]{entity_type{3}, entity_type{42}};
+        const entity_type entity[2u]{entity_type{3}, entity_type{42}}; // NOLINT
 
         switch(policy) {
         case entt::deletion_policy::swap_and_pop: {
@@ -1165,7 +1165,7 @@ TYPED_TEST(SparseSet, PushOutOfBounds) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity[2u]{entity_type{0}, entity_type{traits_type::page_size}};
+        const entity_type entity[2u]{entity_type{0}, entity_type{traits_type::page_size}}; // NOLINT
 
         ASSERT_EQ(*set.push(entity[0u]), entity[0u]);
         ASSERT_EQ(set.extent(), traits_type::page_size);
@@ -1186,7 +1186,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Push) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity[2u]{entity_type{3}, entity_type{42}};
+        const entity_type entity[2u]{entity_type{3}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
 
@@ -1203,7 +1203,7 @@ TYPED_TEST(SparseSet, Bump) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)};
+        const entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
 
@@ -1233,7 +1233,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Bump) {
         case entt::deletion_policy::swap_and_pop:
             ASSERT_DEATH(set.bump(entt::null), "");
             ASSERT_DEATH(set.bump(entt::tombstone), "");
-            ASSERT_DEATH(set.bump(entity_type{42}), "");
+            ASSERT_DEATH(set.bump(entity_type{42}), ""); // NOLINT
             break;
         case entt::deletion_policy::in_place:
         case entt::deletion_policy::swap_only:
@@ -1251,7 +1251,7 @@ TYPED_TEST(SparseSet, Erase) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)};
+        entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)}; // NOLINT
 
         switch(policy) {
         case entt::deletion_policy::swap_and_pop: {
@@ -1265,7 +1265,7 @@ TYPED_TEST(SparseSet, Erase) {
             ASSERT_EQ(set.free_list(), traits_type::entity_mask);
 
             set.push(std::begin(entity), std::end(entity));
-            set.erase(entity, entity + 2u);
+            set.erase(entity, entity + 2u); // NOLINT
 
             ASSERT_EQ(set.size(), 1u);
             ASSERT_EQ(set.free_list(), traits_type::entity_mask);
@@ -1292,8 +1292,8 @@ TYPED_TEST(SparseSet, Erase) {
             ASSERT_EQ(set.current(entity[2u]), traits_type::to_version(entt::tombstone));
 
             set.push(entity[0u]);
-            set.push(std::begin(entity) + 1, std::end(entity));
-            set.erase(entity, entity + 2u);
+            set.push(std::begin(entity) + 1, std::end(entity)); // NOLINT
+            set.erase(entity, entity + 2u);                     // NOLINT
 
             ASSERT_EQ(set.size(), 5u);
             ASSERT_EQ(set.free_list(), 3u);
@@ -1323,7 +1323,7 @@ TYPED_TEST(SparseSet, Erase) {
             ASSERT_TRUE(set.contains(traits_type::next(entity[2u])));
 
             set.push(std::begin(entity), std::end(entity));
-            set.erase(entity, entity + 2u);
+            set.erase(entity, entity + 2u); // NOLINT
 
             ASSERT_EQ(set.size(), 3u);
             ASSERT_EQ(set.free_list(), 1u);
@@ -1352,10 +1352,10 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Erase) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[2u]{entity_type{42}, traits_type::construct(9, 3)};
+        entity_type entity[2u]{entity_type{42}, traits_type::construct(9, 3)}; // NOLINT
 
         ASSERT_DEATH(set.erase(std::begin(entity), std::end(entity)), "");
-        ASSERT_DEATH(set.erase(entity, entity + 2u), "");
+        ASSERT_DEATH(set.erase(entity, entity + 2u), ""); // NOLINT
     }
 }
 
@@ -1367,7 +1367,7 @@ TYPED_TEST(SparseSet, CrossErase) {
         sparse_set_type set{policy};
         sparse_set_type other{policy};
 
-        entity_type entity[2u]{entity_type{3}, entity_type{42}};
+        entity_type entity[2u]{entity_type{3}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         other.push(entity[1u]);
@@ -1387,7 +1387,7 @@ TYPED_TEST(SparseSet, Remove) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)};
+        entity_type entity[3u]{entity_type{3}, entity_type{42}, traits_type::construct(9, 3)}; // NOLINT
 
         switch(policy) {
         case entt::deletion_policy::swap_and_pop: {
@@ -1409,7 +1409,7 @@ TYPED_TEST(SparseSet, Remove) {
 
             set.push(std::begin(entity), std::end(entity));
 
-            ASSERT_EQ(set.remove(entity, entity + 2u), 2u);
+            ASSERT_EQ(set.remove(entity, entity + 2u), 2u); // NOLINT
 
             ASSERT_EQ(set.size(), 1u);
             ASSERT_EQ(set.free_list(), traits_type::entity_mask);
@@ -1444,9 +1444,9 @@ TYPED_TEST(SparseSet, Remove) {
             ASSERT_EQ(set.current(entity[2u]), traits_type::to_version(entt::tombstone));
 
             set.push(entity[0u]);
-            set.push(std::begin(entity) + 1, std::end(entity));
+            set.push(std::begin(entity) + 1, std::end(entity)); // NOLINT
 
-            ASSERT_EQ(set.remove(entity, entity + 2u), 2u);
+            ASSERT_EQ(set.remove(entity, entity + 2u), 2u); // NOLINT
 
             ASSERT_EQ(set.size(), 5u);
             ASSERT_EQ(set.free_list(), 3u);
@@ -1485,7 +1485,7 @@ TYPED_TEST(SparseSet, Remove) {
 
             set.push(std::begin(entity), std::end(entity));
 
-            ASSERT_EQ(set.remove(entity, entity + 2u), 2u);
+            ASSERT_EQ(set.remove(entity, entity + 2u), 2u); // NOLINT
 
             ASSERT_EQ(set.size(), 3u);
             ASSERT_EQ(set.free_list(), 1u);
@@ -1519,7 +1519,7 @@ TYPED_TEST(SparseSet, CrossRemove) {
         sparse_set_type set{policy};
         sparse_set_type other{policy};
 
-        entity_type entity[2u]{entity_type{3}, entity_type{42}};
+        entity_type entity[2u]{entity_type{3}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         other.push(entity[1u]);
@@ -1539,8 +1539,8 @@ TYPED_TEST(SparseSet, Compact) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{3};
-        const entity_type other{42};
+        const entity_type entity{3}; // NOLINT
+        const entity_type other{42}; // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -1638,8 +1638,8 @@ TYPED_TEST(SparseSet, SwapElements) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const auto entity = traits_type::construct(3, 5);
-        const auto other = traits_type::construct(42, 99);
+        const auto entity = traits_type::construct(3, 5);  // NOLINT
+        const auto other = traits_type::construct(42, 99); // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -1661,8 +1661,8 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SwapElements) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const auto entity = traits_type::construct(3, 5);
-        const auto other = traits_type::construct(42, 99);
+        const auto entity = traits_type::construct(3, 5);  // NOLINT
+        const auto other = traits_type::construct(42, 99); // NOLINT
 
         // swap_elements works the same in all cases, test only once
         switch(policy) {
@@ -1689,7 +1689,7 @@ TYPED_TEST(SparseSet, Clear) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[3u]{entity_type{3}, entity_type{42}, entity_type{9}};
+        entity_type entity[3u]{entity_type{3}, entity_type{42}, entity_type{9}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         set.erase(entity[1u]);
@@ -1706,7 +1706,7 @@ TYPED_TEST(SparseSet, SortOrdered) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[5u]{entity_type{42}, entity_type{12}, entity_type{9}, entity_type{7}, entity_type{3}};
+        entity_type entity[5u]{entity_type{42}, entity_type{12}, entity_type{9}, entity_type{7}, entity_type{3}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         set.sort(std::less{});
@@ -1722,7 +1722,7 @@ TYPED_TEST(SparseSet, SortReverse) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[5u]{entity_type{3}, entity_type{7}, entity_type{9}, entity_type{12}, entity_type{42}};
+        entity_type entity[5u]{entity_type{3}, entity_type{7}, entity_type{9}, entity_type{12}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         set.sort(std::less{});
@@ -1738,7 +1738,7 @@ TYPED_TEST(SparseSet, SortUnordered) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[5u]{entity_type{9}, entity_type{7}, entity_type{3}, entity_type{12}, entity_type{42}};
+        entity_type entity[5u]{entity_type{9}, entity_type{7}, entity_type{3}, entity_type{12}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         set.sort(std::less{});
@@ -1763,8 +1763,8 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Sort) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{42};
-        const entity_type other{3};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         set.push(entity);
         set.push(other);
@@ -1789,7 +1789,7 @@ TYPED_TEST(SparseSet, SortN) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        entity_type entity[5u]{entity_type{7}, entity_type{9}, entity_type{3}, entity_type{12}, entity_type{42}};
+        entity_type entity[5u]{entity_type{7}, entity_type{9}, entity_type{3}, entity_type{12}, entity_type{42}}; // NOLINT
 
         set.push(std::begin(entity), std::end(entity));
         set.sort_n(0u, std::less{});
@@ -1801,7 +1801,7 @@ TYPED_TEST(SparseSet, SortN) {
         ASSERT_EQ(set.data()[0u], entity[1u]);
         ASSERT_EQ(set.data()[1u], entity[0u]);
 
-        set.sort_n(5u, std::less{});
+        set.sort_n(5u, std::less{}); // NOLINT
 
         auto begin = set.begin();
         auto end = set.end();
@@ -1823,8 +1823,8 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortN) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        const entity_type entity{42};
-        const entity_type other{3};
+        const entity_type entity{42}; // NOLINT
+        const entity_type other{3};   // NOLINT
 
         ASSERT_DEATH(set.sort_n(1u, std::less{}), "");
 
@@ -1857,7 +1857,7 @@ TYPED_TEST(SparseSet, SortAsDisjoint) {
         sparse_set_type lhs{policy};
         const sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[3u]{entity_type{3}, entity_type{12}, entity_type{42}};
+        entity_type lhs_entity[3u]{entity_type{3}, entity_type{12}, entity_type{42}}; // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
 
@@ -1877,8 +1877,8 @@ TYPED_TEST(SparseSet, SortAsOverlap) {
         sparse_set_type lhs{policy};
         sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[3u]{entity_type{3}, entity_type{12}, entity_type{42}};
-        entity_type rhs_entity[1u]{entity_type{12}};
+        entity_type lhs_entity[3u]{entity_type{3}, entity_type{12}, entity_type{42}}; // NOLINT
+        entity_type rhs_entity[1u]{entity_type{12}};                                  // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
         rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -1906,8 +1906,8 @@ TYPED_TEST(SparseSet, SortAsOrdered) {
         sparse_set_type lhs{policy};
         sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};
-        entity_type rhs_entity[6u]{entity_type{6}, entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};
+        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};                 // NOLINT
+        entity_type rhs_entity[6u]{entity_type{6}, entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}}; // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
         rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -1929,8 +1929,8 @@ TYPED_TEST(SparseSet, SortAsReverse) {
         sparse_set_type lhs{policy};
         sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};
-        entity_type rhs_entity[6u]{entity_type{5}, entity_type{4}, entity_type{3}, entity_type{2}, entity_type{1}, entity_type{6}};
+        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};                 // NOLINT
+        entity_type rhs_entity[6u]{entity_type{5}, entity_type{4}, entity_type{3}, entity_type{2}, entity_type{1}, entity_type{6}}; // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
         rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -1961,8 +1961,8 @@ TYPED_TEST(SparseSet, SortAsUnordered) {
         sparse_set_type lhs{policy};
         sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};
-        entity_type rhs_entity[6u]{entity_type{3}, entity_type{2}, entity_type{6}, entity_type{1}, entity_type{4}, entity_type{5}};
+        entity_type lhs_entity[5u]{entity_type{1}, entity_type{2}, entity_type{3}, entity_type{4}, entity_type{5}};                 // NOLINT
+        entity_type rhs_entity[6u]{entity_type{3}, entity_type{2}, entity_type{6}, entity_type{1}, entity_type{4}, entity_type{5}}; // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
         rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -1994,8 +1994,8 @@ TYPED_TEST(SparseSet, SortAsInvalid) {
         sparse_set_type lhs{policy};
         sparse_set_type rhs{policy};
 
-        entity_type lhs_entity[3u]{entity_type{1}, entity_type{2}, traits_type::construct(3, 1)};
-        entity_type rhs_entity[3u]{entity_type{2}, entity_type{1}, traits_type::construct(3, 2)};
+        entity_type lhs_entity[3u]{entity_type{1}, entity_type{2}, traits_type::construct(3, 1)}; // NOLINT
+        entity_type rhs_entity[3u]{entity_type{2}, entity_type{1}, traits_type::construct(3, 2)}; // NOLINT
 
         lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
         rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -2031,7 +2031,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
             SUCCEED();
         } break;
         case entt::deletion_policy::in_place: {
-            const entity_type entity{42};
+            const entity_type entity{42}; // NOLINT
 
             lhs.push(entity);
             lhs.erase(entity);
@@ -2039,7 +2039,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
             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}};
+            entity_type entity[3u]{entity_type{3}, entity_type{42}, entity_type{9}}; // NOLINT
 
             lhs.push(std::begin(entity), std::end(entity));
             rhs.push(std::rbegin(entity), std::rend(entity));
@@ -2058,7 +2058,7 @@ TYPED_TEST(SparseSet, CanModifyDuringIteration) {
 
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
-        set.push(entity_type{0});
+        set.push(entity_type{0}); // NOLINT
 
         ASSERT_EQ(set.capacity(), 1u);
 
@@ -2086,8 +2086,8 @@ TYPED_TEST(SparseSet, CustomAllocator) {
 
         ASSERT_EQ(set.capacity(), 1u);
 
-        set.push(entity_type{0});
-        set.push(entity_type{1});
+        set.push(entity_type{0}); // NOLINT
+        set.push(entity_type{1}); // NOLINT
 
         entt::basic_sparse_set<entity_type, test::throwing_allocator<entity_type>> other{std::move(set), allocator};
 
@@ -2145,7 +2145,7 @@ TYPED_TEST(SparseSet, ThrowingAllocator) {
         ASSERT_EQ(set.extent(), traits_type::page_size);
         ASSERT_EQ(set.capacity(), 0u);
 
-        set.push(entity_type{0});
+        set.push(entity_type{0}); // NOLINT
         set.get_allocator().template throw_counter<entity_type>(0u);
 
         ASSERT_THROW(set.reserve(2u), test::throwing_allocator_exception);
@@ -2155,19 +2155,19 @@ TYPED_TEST(SparseSet, ThrowingAllocator) {
 
         set.get_allocator().template throw_counter<entity_type>(0u);
 
-        ASSERT_THROW(set.push(entity_type{1}), test::throwing_allocator_exception);
+        ASSERT_THROW(set.push(entity_type{1}), test::throwing_allocator_exception); // NOLINT
         ASSERT_EQ(set.extent(), traits_type::page_size);
-        ASSERT_TRUE(set.contains(entity_type{0}));
-        ASSERT_FALSE(set.contains(entity_type{1}));
+        ASSERT_TRUE(set.contains(entity_type{0}));  // NOLINT
+        ASSERT_FALSE(set.contains(entity_type{1})); // NOLINT
         ASSERT_EQ(set.capacity(), 1u);
 
-        entity_type entity[2u]{entity_type{1}, entity_type{traits_type::page_size}};
+        entity_type entity[2u]{entity_type{1}, entity_type{traits_type::page_size}}; // NOLINT
         set.get_allocator().template throw_counter<entity_type>(1u);
 
         ASSERT_THROW(set.push(std::begin(entity), std::end(entity)), test::throwing_allocator_exception);
         ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
-        ASSERT_TRUE(set.contains(entity_type{0}));
-        ASSERT_TRUE(set.contains(entity_type{1}));
+        ASSERT_TRUE(set.contains(entity_type{0})); // NOLINT
+        ASSERT_TRUE(set.contains(entity_type{1})); // NOLINT
         ASSERT_FALSE(set.contains(entity_type{traits_type::page_size}));
         ASSERT_EQ(set.capacity(), 2u);
         ASSERT_EQ(set.size(), 2u);

test/entt/entity/storage.cpp

@@ -139,7 +139,7 @@ TYPED_TEST(Storage, Move) {
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{3});
 
     other = entt::storage<value_type>{};
-    other.emplace(entt::entity{42}, 42);
+    other.emplace(entt::entity{42}, 42); // NOLINT
     other = std::move(pool);
 
     ASSERT_TRUE(pool.empty()); // NOLINT
@@ -161,10 +161,10 @@ TYPED_TEST(Storage, Swap) {
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
-    pool.emplace(entt::entity{42}, 41);
-    other.emplace(entt::entity{9}, 8);
+    pool.emplace(entt::entity{42}, 41); // NOLINT
+    other.emplace(entt::entity{9}, 8);  // NOLINT
     other.emplace(entt::entity{3}, 2);
-    other.erase(entt::entity{9});
+    other.erase(entt::entity{9}); // NOLINT
 
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(other.size(), 1u + traits_type::in_place_delete);
@@ -189,7 +189,7 @@ TYPED_TEST(Storage, Capacity) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    pool.reserve(42);
+    pool.reserve(42); // NOLINT
 
     ASSERT_EQ(pool.capacity(), traits_type::page_size);
     ASSERT_TRUE(pool.empty());
@@ -237,7 +237,7 @@ TYPED_TEST(Storage, Raw) {
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 3);
-    pool.emplace(entt::entity{12}, 6);
+    pool.emplace(entt::entity{12}, 6); // NOLINT
 
     ASSERT_EQ(pool.raw()[0u][0u], value_type{3});
     ASSERT_EQ(std::as_const(pool).raw()[0u][1u], value_type{6});
@@ -252,7 +252,7 @@ TYPED_TEST(Storage, Iterator) {
     testing::StaticAssertTypeEq<typename iterator::reference, value_type &>();
 
     entt::storage<value_type> pool;
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     iterator end{pool.begin()};
     iterator begin{};
@@ -296,7 +296,7 @@ TYPED_TEST(Storage, Iterator) {
     ASSERT_EQ(begin.index(), 0);
     ASSERT_EQ(end.index(), -1);
 
-    pool.emplace(entt::entity{42}, 3);
+    pool.emplace(entt::entity{42}, 3); // NOLINT
     begin = pool.begin();
 
     ASSERT_EQ(begin.index(), 1);
@@ -315,7 +315,7 @@ TYPED_TEST(Storage, ConstIterator) {
     testing::StaticAssertTypeEq<typename iterator::reference, const value_type &>();
 
     entt::storage<value_type> pool;
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     iterator cend{pool.cbegin()};
     iterator cbegin{};
@@ -360,7 +360,7 @@ TYPED_TEST(Storage, ConstIterator) {
     ASSERT_EQ(cbegin.index(), 0);
     ASSERT_EQ(cend.index(), -1);
 
-    pool.emplace(entt::entity{42}, 3);
+    pool.emplace(entt::entity{42}, 3); // NOLINT
     cbegin = pool.cbegin();
 
     ASSERT_EQ(cbegin.index(), 1);
@@ -379,7 +379,7 @@ TYPED_TEST(Storage, ReverseIterator) {
     testing::StaticAssertTypeEq<typename reverse_iterator::reference, value_type &>();
 
     entt::storage<value_type> pool;
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     reverse_iterator end{pool.rbegin()};
     reverse_iterator begin{};
@@ -422,7 +422,7 @@ TYPED_TEST(Storage, ReverseIterator) {
     ASSERT_EQ(begin.base().index(), -1);
     ASSERT_EQ(end.base().index(), 0);
 
-    pool.emplace(entt::entity{42}, 3);
+    pool.emplace(entt::entity{42}, 3); // NOLINT
     end = pool.rend();
 
     ASSERT_EQ(begin.base().index(), -1);
@@ -441,7 +441,7 @@ TYPED_TEST(Storage, ConstReverseIterator) {
     testing::StaticAssertTypeEq<typename const_reverse_iterator::reference, const value_type &>();
 
     entt::storage<value_type> pool;
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const_reverse_iterator cend{pool.crbegin()};
     const_reverse_iterator cbegin{};
@@ -486,7 +486,7 @@ TYPED_TEST(Storage, ConstReverseIterator) {
     ASSERT_EQ(cbegin.base().index(), -1);
     ASSERT_EQ(cend.base().index(), 0);
 
-    pool.emplace(entt::entity{42}, 3);
+    pool.emplace(entt::entity{42}, 3); // NOLINT
     cend = pool.crend();
 
     ASSERT_EQ(cbegin.base().index(), -1);
@@ -500,7 +500,7 @@ TYPED_TEST(Storage, IteratorConversion) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const typename entt::storage<value_type>::iterator it = pool.begin();
     typename entt::storage<value_type>::const_iterator cit = it;
@@ -542,7 +542,7 @@ TYPED_TEST(Storage, Getters) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{41}, 3);
+    pool.emplace(entt::entity{41}, 3); // NOLINT
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), value_type &>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), const value_type &>();
@@ -572,7 +572,7 @@ TYPED_TEST(Storage, Value) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     ASSERT_EQ(pool.value(entt::entity{42}), &pool.get(entt::entity{42}));
 }
@@ -612,7 +612,7 @@ TEST(Storage, EmplaceSelfMoveSupport) {
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
 
-    pool.emplace(entity).insert(42);
+    pool.emplace(entity).insert(42); // NOLINT
     pool.erase(entity);
 
     ASSERT_FALSE(pool.contains(entity));
@@ -625,7 +625,7 @@ TEST(Storage, EmplaceSelfMoveSupportInPlaceDelete) {
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::in_place);
 
-    pool.emplace(entity).insert(42);
+    pool.emplace(entity).insert(42); // NOLINT
     pool.erase(entity);
 
     ASSERT_FALSE(pool.contains(entity));
@@ -637,8 +637,8 @@ TYPED_TEST(Storage, TryEmplace) {
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
 
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
-    value_type instance{42};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
+    value_type instance{42};                                    // NOLINT
 
     ASSERT_NE(base.push(entity[0u], &instance), base.end());
 
@@ -689,7 +689,7 @@ TEST(Storage, TryEmplaceNonDefaultConstructible) {
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
 
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
     ASSERT_EQ(pool.type(), base.type());
@@ -704,7 +704,7 @@ TEST(Storage, TryEmplaceNonDefaultConstructible) {
     ASSERT_EQ(base.find(entity[0u]), base.end());
     ASSERT_TRUE(pool.empty());
 
-    int value = 42;
+    int value = 42; // NOLINT
     value_type instance{value, value};
 
     ASSERT_NE(base.push(entity[0u], &instance), base.end());
@@ -733,7 +733,7 @@ TEST(Storage, TryEmplaceNonCopyConstructible) {
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
 
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
     ASSERT_EQ(pool.type(), base.type());
@@ -806,10 +806,10 @@ TYPED_TEST(Storage, Insert) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
     typename entt::storage<value_type>::iterator it{};
 
-    it = pool.insert(std::begin(entity), std::end(entity), value_type{99});
+    it = pool.insert(std::begin(entity), std::end(entity), value_type{99}); // NOLINT
 
     ASSERT_EQ(it, pool.cbegin());
 
@@ -823,7 +823,7 @@ TYPED_TEST(Storage, Insert) {
     ASSERT_EQ(*it++.operator->(), value_type{99});
     ASSERT_EQ(*it.operator->(), value_type{99});
 
-    const value_type values[2u] = {value_type{42}, value_type{3}};
+    const value_type values[2u] = {value_type{42}, value_type{3}}; // NOLINT
 
     pool.erase(std::begin(entity), std::end(entity));
     it = pool.insert(std::rbegin(entity), std::rend(entity), std::begin(values));
@@ -851,8 +851,8 @@ TYPED_TEST(Storage, Erase) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
-    const value_type values[3u]{value_type{0}, value_type{1}, value_type{2}};
+    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}}; // NOLINT
+    const value_type values[3u]{value_type{0}, value_type{1}, value_type{2}};    // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity), std::begin(values));
     pool.erase(std::begin(entity), std::end(entity));
@@ -865,7 +865,7 @@ TYPED_TEST(Storage, Erase) {
     }
 
     pool.insert(std::begin(entity), std::end(entity), std::begin(values));
-    pool.erase(entity, entity + 2u);
+    pool.erase(entity, entity + 2u); // NOLINT
 
     ASSERT_EQ(*pool.begin(), values[2u]);
 
@@ -891,10 +891,10 @@ TYPED_TEST(Storage, CrossErase) {
     entt::storage<value_type> pool;
     entt::sparse_set set;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     pool.emplace(entity[0u], 3);
-    pool.emplace(entity[1u], 42);
+    pool.emplace(entity[1u], 42); // NOLINT
     set.push(entity[1u]);
     pool.erase(set.begin(), set.end());
 
@@ -908,8 +908,8 @@ TYPED_TEST(Storage, Remove) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
-    const value_type values[3u]{value_type{0}, value_type{1}, value_type{2}};
+    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}}; // NOLINT
+    const value_type values[3u]{value_type{0}, value_type{1}, value_type{2}};    // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity), std::begin(values));
 
@@ -925,7 +925,7 @@ TYPED_TEST(Storage, Remove) {
 
     pool.insert(std::begin(entity), std::end(entity), std::begin(values));
 
-    ASSERT_EQ(pool.remove(entity, entity + 2u), 2u);
+    ASSERT_EQ(pool.remove(entity, entity + 2u), 2u); // NOLINT
     ASSERT_EQ(*pool.begin(), values[2u]);
 
     if constexpr(traits_type::in_place_delete) {
@@ -951,10 +951,10 @@ TYPED_TEST(Storage, CrossRemove) {
     entt::storage<value_type> pool;
     entt::sparse_set set;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     pool.emplace(entity[0u], 3);
-    pool.emplace(entity[1u], 42);
+    pool.emplace(entity[1u], 42); // NOLINT
     set.push(entity[1u]);
     pool.remove(set.begin(), set.end());
 
@@ -968,7 +968,7 @@ TYPED_TEST(Storage, Clear) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
+    entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
 
@@ -1004,7 +1004,7 @@ TYPED_TEST(Storage, Compact) {
 
     ASSERT_EQ(pool.size(), 1u);
 
-    pool.emplace(entt::entity{42}, value_type{42});
+    pool.emplace(entt::entity{42}, value_type{42}); // NOLINT
     pool.erase(entt::entity{0});
 
     ASSERT_EQ(pool.size(), 1u + traits_type::in_place_delete);
@@ -1027,7 +1027,7 @@ TYPED_TEST(Storage, Compact) {
     ASSERT_EQ(pool.get(entt::entity{0}), value_type{0});
 
     pool.erase(entt::entity{0});
-    pool.erase(entt::entity{42});
+    pool.erase(entt::entity{42}); // NOLINT
     pool.compact();
 
     ASSERT_TRUE(pool.empty());
@@ -1039,17 +1039,17 @@ TYPED_TEST(Storage, SwapElements) {
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 3);
-    pool.emplace(entt::entity{12}, 6);
-    pool.emplace(entt::entity{42}, 9);
+    pool.emplace(entt::entity{12}, 6); // NOLINT
+    pool.emplace(entt::entity{42}, 9); // NOLINT
 
-    pool.erase(entt::entity{12});
+    pool.erase(entt::entity{12}); // NOLINT
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{3});
     ASSERT_EQ(pool.get(entt::entity{42}), value_type{9});
     ASSERT_EQ(pool.index(entt::entity{3}), 0u);
     ASSERT_EQ(pool.index(entt::entity{42}), 1u + traits_type::in_place_delete);
 
-    pool.swap_elements(entt::entity{3}, entt::entity{42});
+    pool.swap_elements(entt::entity{3}, entt::entity{42}); // NOLINT
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{3});
     ASSERT_EQ(pool.get(entt::entity{42}), value_type{9});
@@ -1068,8 +1068,8 @@ TYPED_TEST(Storage, Iterable) {
     entt::storage<value_type> pool;
     const entt::sparse_set &base = pool;
 
-    pool.emplace(entt::entity{1}, 99);
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{1}, 99); // NOLINT
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     auto iterable = pool.each();
 
@@ -1115,8 +1115,8 @@ TYPED_TEST(Storage, ConstIterable) {
     entt::storage<value_type> pool;
     const entt::sparse_set &base = pool;
 
-    pool.emplace(entt::entity{1}, 99);
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{1}, 99); // NOLINT
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     auto iterable = std::as_const(pool).each();
 
@@ -1155,7 +1155,7 @@ TYPED_TEST(Storage, IterableIteratorConversion) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const typename entt::storage<value_type>::iterable::iterator it = pool.each().begin();
     typename entt::storage<value_type>::const_iterable::iterator cit = it;
@@ -1171,7 +1171,7 @@ TYPED_TEST(Storage, IterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const auto iterable = pool.each();
     const auto it = std::find_if(iterable.begin(), iterable.end(), [](auto args) { return std::get<0>(args) == entt::entity{3}; });
@@ -1190,8 +1190,8 @@ TYPED_TEST(Storage, ReverseIterable) {
     entt::storage<value_type> pool;
     const entt::sparse_set &base = pool;
 
-    pool.emplace(entt::entity{1}, 99);
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{1}, 99); // NOLINT
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     auto iterable = pool.reach();
 
@@ -1237,8 +1237,8 @@ TYPED_TEST(Storage, ConstReverseIterable) {
     entt::storage<value_type> pool;
     const entt::sparse_set &base = pool;
 
-    pool.emplace(entt::entity{1}, 99);
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{1}, 99); // NOLINT
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     auto iterable = std::as_const(pool).reach();
 
@@ -1277,7 +1277,7 @@ TYPED_TEST(Storage, ReverseIterableIteratorConversion) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const typename entt::storage<value_type>::reverse_iterable::iterator it = pool.reach().begin();
     typename entt::storage<value_type>::const_reverse_iterable::iterator cit = it;
@@ -1293,7 +1293,7 @@ TYPED_TEST(Storage, ReverseIterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{3}, 42);
+    pool.emplace(entt::entity{3}, 42); // NOLINT
 
     const auto iterable = pool.reach();
     const auto it = std::find_if(iterable.begin(), iterable.end(), [](auto args) { return std::get<0>(args) == entt::entity{3}; });
@@ -1305,10 +1305,10 @@ TYPED_TEST(Storage, SortOrdered) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
-    value_type values[5u]{value_type{12}, value_type{9}, value_type{6}, value_type{3}, value_type{1}};
+    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}}; // NOLINT
+    value_type values[5u]{value_type{12}, value_type{9}, value_type{6}, value_type{3}, value_type{1}};              // NOLINT
 
-    pool.insert(std::begin(entity), std::end(entity), values);
+    pool.insert(std::begin(entity), std::end(entity), values); // NOLINT
     pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); });
 
     ASSERT_TRUE(std::equal(std::rbegin(entity), std::rend(entity), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -1319,10 +1319,10 @@ TYPED_TEST(Storage, SortReverse) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
-    value_type values[5u]{value_type{1}, value_type{3}, value_type{6}, value_type{9}, value_type{12}};
+    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}}; // NOLINT
+    value_type values[5u]{value_type{1}, value_type{3}, value_type{6}, value_type{9}, value_type{12}};              // NOLINT
 
-    pool.insert(std::begin(entity), std::end(entity), values);
+    pool.insert(std::begin(entity), std::end(entity), values); // NOLINT
     pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); });
 
     ASSERT_TRUE(std::equal(std::begin(entity), std::end(entity), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -1333,10 +1333,10 @@ TYPED_TEST(Storage, SortUnordered) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
-    value_type values[5u]{value_type{6}, value_type{3}, value_type{1}, value_type{9}, value_type{12}};
+    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}}; // NOLINT
+    value_type values[5u]{value_type{6}, value_type{3}, value_type{1}, value_type{9}, value_type{12}};              // NOLINT
 
-    pool.insert(std::begin(entity), std::end(entity), values);
+    pool.insert(std::begin(entity), std::end(entity), values); // NOLINT
     pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); });
 
     auto begin = pool.begin();
@@ -1360,10 +1360,10 @@ TYPED_TEST(Storage, SortN) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
-    value_type values[5u]{value_type{3}, value_type{6}, value_type{1}, value_type{9}, value_type{12}};
+    entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}}; // NOLINT
+    value_type values[5u]{value_type{3}, value_type{6}, value_type{1}, value_type{9}, value_type{12}};              // NOLINT
 
-    pool.insert(std::begin(entity), std::end(entity), values);
+    pool.insert(std::begin(entity), std::end(entity), values); // NOLINT
     pool.sort_n(0u, [&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); });
 
     ASSERT_TRUE(std::equal(std::rbegin(entity), std::rend(entity), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -1379,7 +1379,7 @@ TYPED_TEST(Storage, SortN) {
     ASSERT_EQ(pool.data()[1u], entity[0u]);
     ASSERT_EQ(pool.data()[2u], entity[2u]);
 
-    pool.sort_n(5u, [&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); });
+    pool.sort_n(5u, [&pool](auto lhs, auto rhs) { return pool.get(lhs) < pool.get(rhs); }); // NOLINT
 
     auto begin = pool.begin();
     auto end = pool.end();
@@ -1403,10 +1403,10 @@ TYPED_TEST(Storage, SortAsDisjoint) {
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
-    value_type lhs_values[3u]{value_type{3}, value_type{6}, value_type{9}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
+    value_type lhs_values[3u]{value_type{3}, value_type{6}, value_type{9}};           // NOLINT
 
-    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values);
+    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values); // NOLINT
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -1422,15 +1422,15 @@ TYPED_TEST(Storage, SortAsOverlap) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
-    value_type lhs_values[3u]{value_type{3}, value_type{6}, value_type{9}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
+    value_type lhs_values[3u]{value_type{3}, value_type{6}, value_type{9}};           // NOLINT
 
-    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values);
+    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values); // NOLINT
 
-    entt::entity rhs_entity[1u]{entt::entity{12}};
-    value_type rhs_values[1u]{value_type{6}};
+    entt::entity rhs_entity[1u]{entt::entity{12}}; // NOLINT
+    value_type rhs_values[1u]{value_type{6}};      // NOLINT
 
-    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values);
+    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values); // NOLINT
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -1458,15 +1458,15 @@ TYPED_TEST(Storage, SortAsOrdered) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
+    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};             // NOLINT
 
-    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values);
+    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values); // NOLINT
 
-    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    value_type rhs_values[6u]{value_type{6}, value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};
+    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
+    value_type rhs_values[6u]{value_type{6}, value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};               // NOLINT
 
-    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values);
+    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values); // NOLINT
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -1485,15 +1485,15 @@ TYPED_TEST(Storage, SortAsReverse) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
+    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};             // NOLINT
 
-    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values);
+    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values); // NOLINT
 
-    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}};
-    value_type rhs_values[6u]{value_type{5}, value_type{4}, value_type{3}, value_type{2}, value_type{1}, value_type{6}};
+    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}}; // NOLINT
+    value_type rhs_values[6u]{value_type{5}, value_type{4}, value_type{3}, value_type{2}, value_type{1}, value_type{6}};               // NOLINT
 
-    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values);
+    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values); // NOLINT
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -1527,15 +1527,15 @@ TYPED_TEST(Storage, SortAsUnordered) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
+    value_type lhs_values[5u]{value_type{1}, value_type{2}, value_type{3}, value_type{4}, value_type{5}};             // NOLINT
 
-    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values);
+    lhs.insert(std::begin(lhs_entity), std::end(lhs_entity), lhs_values); // NOLINT
 
-    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}};
-    value_type rhs_values[6u]{value_type{3}, value_type{2}, value_type{6}, value_type{1}, value_type{4}, value_type{5}};
+    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}}; // NOLINT
+    value_type rhs_values[6u]{value_type{3}, value_type{2}, value_type{6}, value_type{1}, value_type{4}, value_type{5}};               // NOLINT
 
-    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values);
+    rhs.insert(std::begin(rhs_entity), std::end(rhs_entity), rhs_values); // NOLINT
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entity), std::rend(lhs_entity), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -1601,7 +1601,7 @@ TYPED_TEST(Storage, CanModifyDuringIteration) {
     using traits_type = entt::component_traits<value_type>;
     entt::storage<value_type> pool;
 
-    auto *ptr = &pool.emplace(entt::entity{0}, 42);
+    auto *ptr = &pool.emplace(entt::entity{0}, 42); // NOLINT
 
     ASSERT_EQ(pool.capacity(), traits_type::page_size);
 
@@ -1627,7 +1627,7 @@ TYPED_TEST(Storage, ReferencesGuaranteed) {
 
     for(auto &&elem: pool) {
         if(!(elem == value_type{})) {
-            elem = value_type{42};
+            elem = value_type{42}; // NOLINT
         }
     }
 
@@ -1646,7 +1646,7 @@ TYPED_TEST(Storage, ReferencesGuaranteed) {
 
 TEST(Storage, UpdateFromDestructor) {
     constexpr auto size = 10u;
-    const entt::entity entity[3u]{entt::entity{9u}, entt::entity{8u}, entt::entity{0u}};
+    const entt::entity entity[3u]{entt::entity{9u}, entt::entity{8u}, entt::entity{0u}}; // NOLINT
 
     for(auto target: entity) {
         entt::storage<update_from_destructor> pool;
@@ -1768,7 +1768,7 @@ TYPED_TEST(Storage, ThrowingAllocator) {
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entt::entity{0}, 0);
-    const entt::entity entity[2u]{entt::entity{1}, entt::entity{sparse_page_size}};
+    const entt::entity entity[2u]{entt::entity{1}, entt::entity{sparse_page_size}}; // NOLINT
     pool.get_allocator().template throw_counter<entt::entity>(1u);
 
     ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), value_type{0}), test::throwing_allocator_exception);
@@ -1776,7 +1776,7 @@ TYPED_TEST(Storage, ThrowingAllocator) {
     ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
     pool.erase(entt::entity{1});
-    const value_type components[2u]{value_type{1}, value_type{sparse_page_size}};
+    const value_type components[2u]{value_type{1}, value_type{sparse_page_size}}; // NOLINT
     pool.get_allocator().template throw_counter<entt::entity>(0u);
     pool.compact();
 
@@ -1788,8 +1788,8 @@ TYPED_TEST(Storage, ThrowingAllocator) {
 TEST(Storage, ThrowingComponent) {
     entt::storage<test::throwing_type> pool;
 
-    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}};
-    const test::throwing_type value[2u]{true, false};
+    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}}; // NOLINT
+    const test::throwing_type value[2u]{true, false};                 // NOLINT
 
     // strong exception safety
     ASSERT_THROW(pool.emplace(entity[0u], value[0u]), test::throwing_type_exception);

test/entt/entity/storage_entity.cpp

@@ -67,7 +67,7 @@ TEST(StorageEntity, Move) {
     ASSERT_EQ(pool.index(entt::entity{3}), 0u);
 
     other = entt::storage<entt::entity>{};
-    other.emplace(entt::entity{42});
+    other.emplace(entt::entity{42}); // NOLINT
     other = std::move(pool);
 
     ASSERT_TRUE(pool.empty()); // NOLINT
@@ -86,11 +86,11 @@ TEST(StorageEntity, Swap) {
     ASSERT_EQ(pool.type(), entt::type_id<void>());
     ASSERT_EQ(other.type(), entt::type_id<void>());
 
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
-    other.emplace(entt::entity{9});
+    other.emplace(entt::entity{9}); // NOLINT
     other.emplace(entt::entity{3});
-    other.erase(entt::entity{9});
+    other.erase(entt::entity{9}); // NOLINT
 
     ASSERT_EQ(pool.size(), 43u);
     ASSERT_EQ(other.size(), 10u);
@@ -110,7 +110,7 @@ TEST(StorageEntity, Swap) {
 TEST(StorageEntity, Getters) {
     entt::storage<entt::entity> pool;
 
-    pool.emplace(entt::entity{41});
+    pool.emplace(entt::entity{41}); // NOLINT
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), void>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), void>();
@@ -139,7 +139,7 @@ TEST(StorageEntity, Emplace) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::storage<entt::entity> pool;
-    entt::entity entity[2u]{};
+    entt::entity entity[2u]{}; // NOLINT
 
     ASSERT_EQ(pool.emplace(), entt::entity{0});
     ASSERT_EQ(pool.emplace(entt::null), entt::entity{1});
@@ -164,7 +164,7 @@ TEST(StorageEntity, Emplace) {
     ASSERT_EQ(pool.emplace(), traits_type::construct(2, 1));
 
     pool.erase(traits_type::construct(2, 1));
-    pool.insert(entity, entity + 2u);
+    pool.insert(entity, entity + 2u); // NOLINT
 
     ASSERT_EQ(entity[0u], traits_type::construct(2, 2));
     ASSERT_EQ(entity[1u], entt::entity{8});
@@ -191,9 +191,9 @@ TEST(StorageEntity, TryEmplace) {
     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});
 
-    entt::entity entity[2u]{entt::entity{1}, traits_type::construct(5, 3)};
+    entt::entity entity[2u]{entt::entity{1}, traits_type::construct(5, 3)}; // NOLINT
 
-    pool.erase(entity, entity + 2u);
+    pool.erase(entity, entity + 2u); // NOLINT
     pool.erase(entt::entity{2});
 
     ASSERT_EQ(pool.current(entity[0u]), 1);
@@ -237,7 +237,7 @@ ENTT_DEBUG_TEST(StorageEntityDeathTest, Patch) {
 
 TEST(StorageEntity, Insert) {
     entt::storage<entt::entity> pool;
-    entt::entity entity[2u]{};
+    entt::entity entity[2u]{}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
 
@@ -254,7 +254,7 @@ TEST(StorageEntity, Insert) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_EQ(pool.in_use(), 0u); // NOLINT
 
-    pool.insert(entity, entity + 1u);
+    pool.insert(entity, entity + 1u); // NOLINT
 
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_FALSE(pool.contains(entity[1u]));
@@ -266,9 +266,9 @@ TEST(StorageEntity, Insert) {
 
 TEST(StorageEntity, Pack) {
     entt::storage<entt::entity> pool;
-    entt::entity entity[3u]{entt::entity{1}, entt::entity{3}, entt::entity{42}};
+    entt::entity entity[3u]{entt::entity{1}, entt::entity{3}, entt::entity{42}}; // NOLINT
 
-    pool.push(entity, entity + 3u);
+    pool.push(entity, entity + 3u); // NOLINT
     std::swap(entity[0u], entity[1u]);
 
     const auto len = pool.pack(entity + 1u, entity + 3u); // NOLINT
@@ -327,7 +327,7 @@ TEST(StorageEntity, Iterable) {
 
     pool.emplace(entt::entity{1});
     pool.emplace(entt::entity{3});
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     pool.erase(entt::entity{3});
 
@@ -371,7 +371,7 @@ TEST(StorageEntity, ConstIterable) {
 
     pool.emplace(entt::entity{1});
     pool.emplace(entt::entity{3});
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     pool.erase(entt::entity{3});
 
@@ -439,7 +439,7 @@ TEST(StorageEntity, ReverseIterable) {
 
     pool.emplace(entt::entity{1});
     pool.emplace(entt::entity{3});
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     pool.erase(entt::entity{3});
 
@@ -483,7 +483,7 @@ TEST(StorageEntity, ReverseConstIterable) {
 
     pool.emplace(entt::entity{1});
     pool.emplace(entt::entity{3});
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     pool.erase(entt::entity{3});
 
@@ -543,7 +543,7 @@ TEST(StorageEntity, ReverseIterableAlgorithmCompatibility) {
 TEST(StorageEntity, SortOrdered) {
     entt::storage<entt::entity> pool;
 
-    entt::entity entity[5u]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}};
+    entt::entity entity[5u]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}}; // NOLINT
 
     pool.push(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -554,7 +554,7 @@ TEST(StorageEntity, SortOrdered) {
 TEST(StorageEntity, SortReverse) {
     entt::storage<entt::entity> pool;
 
-    entt::entity entity[5u]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.push(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -565,7 +565,7 @@ TEST(StorageEntity, SortReverse) {
 TEST(StorageEntity, SortUnordered) {
     entt::storage<entt::entity> pool;
 
-    entt::entity entity[5u]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.push(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -580,7 +580,7 @@ TEST(StorageEntity, SortUnordered) {
 TEST(StorageEntity, SortN) {
     entt::storage<entt::entity> pool;
 
-    entt::entity entity[5u]{entt::entity{7}, entt::entity{9}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{7}, entt::entity{9}, entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.push(std::begin(entity), std::end(entity));
     pool.sort_n(0u, std::less{});
@@ -593,7 +593,7 @@ TEST(StorageEntity, SortN) {
     ASSERT_EQ(pool.data()[1u], entity[0u]);
     ASSERT_EQ(pool.data()[2u], entity[2u]);
 
-    pool.sort_n(5u, std::less{});
+    pool.sort_n(5u, std::less{}); // NOLINT
 
     ASSERT_EQ(pool.data()[0u], entity[4u]);
     ASSERT_EQ(pool.data()[1u], entity[3u]);
@@ -606,7 +606,7 @@ TEST(StorageEntity, SortAsDisjoint) {
     entt::storage<entt::entity> lhs;
     const entt::storage<entt::entity> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
 
@@ -621,8 +621,8 @@ TEST(StorageEntity, SortAsOverlap) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
-    entt::entity rhs_entity[1u]{entt::entity{12}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
+    entt::entity rhs_entity[1u]{entt::entity{12}};                                    // NOLINT
 
     lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -641,8 +641,8 @@ TEST(StorageEntity, SortAsOrdered) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
 
     lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -659,8 +659,8 @@ TEST(StorageEntity, SortAsReverse) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}}; // NOLINT
 
     lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.push(std::begin(rhs_entity), std::end(rhs_entity));
@@ -682,8 +682,8 @@ TEST(StorageEntity, SortAsUnordered) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}}; // NOLINT
 
     lhs.push(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.push(std::begin(rhs_entity), std::end(rhs_entity));

test/entt/entity/storage_no_instance.cpp

@@ -30,7 +30,7 @@ struct StorageNoInstance: testing::Test {
         if constexpr(std::is_void_v<type>) {
             return pool.insert(from, to);
         } else {
-            const type values[2u]{};
+            const type values[2u]{}; // NOLINT
             return pool.insert(from, to, std::begin(values));
         }
     }
@@ -110,7 +110,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_EQ(pool.index(entt::entity{3}), 0u);
 
     other = entt::storage<value_type>{};
-    other.emplace(entt::entity{42}, 42);
+    other.emplace(entt::entity{42}, 42); // NOLINT
     other = std::move(pool);
 
     ASSERT_TRUE(pool.empty()); // NOLINT
@@ -130,11 +130,11 @@ TYPED_TEST(StorageNoInstance, Swap) {
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
 
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
-    other.emplace(entt::entity{9});
+    other.emplace(entt::entity{9}); // NOLINT
     other.emplace(entt::entity{3});
-    other.erase(entt::entity{9});
+    other.erase(entt::entity{9}); // NOLINT
 
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(other.size(), 1u);
@@ -155,7 +155,7 @@ TYPED_TEST(StorageNoInstance, Getters) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{41}, 3);
+    pool.emplace(entt::entity{41}, 3); // NOLINT
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), void>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), void>();
@@ -185,7 +185,7 @@ TYPED_TEST(StorageNoInstance, Value) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    pool.emplace(entt::entity{42});
+    pool.emplace(entt::entity{42}); // NOLINT
 
     ASSERT_EQ(pool.value(entt::entity{42}), nullptr);
 }
@@ -201,7 +201,7 @@ TYPED_TEST(StorageNoInstance, Emplace) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     testing::StaticAssertTypeEq<decltype(pool.emplace({})), void>();
 
@@ -228,7 +228,7 @@ TYPED_TEST(StorageNoInstance, TryEmplace) {
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     ASSERT_NE(this->push_instance(pool, entity[0u]), base.end());
 
@@ -283,7 +283,7 @@ TYPED_TEST(StorageNoInstance, Insert) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
 
@@ -303,7 +303,7 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Insert) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
+    const entt::entity entity[2u]{entt::entity{3}, entt::entity{42}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
 
@@ -547,7 +547,7 @@ TYPED_TEST(StorageNoInstance, SortOrdered) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}};
+    entt::entity entity[5u]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -559,7 +559,7 @@ TYPED_TEST(StorageNoInstance, SortReverse) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -571,7 +571,7 @@ TYPED_TEST(StorageNoInstance, SortUnordered) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
     pool.sort(std::less{});
@@ -587,7 +587,7 @@ TYPED_TEST(StorageNoInstance, SortN) {
     using value_type = typename TestFixture::type;
     entt::storage<value_type> pool;
 
-    entt::entity entity[5u]{entt::entity{7}, entt::entity{9}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity entity[5u]{entt::entity{7}, entt::entity{9}, entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     pool.insert(std::begin(entity), std::end(entity));
     pool.sort_n(0u, std::less{});
@@ -600,7 +600,7 @@ TYPED_TEST(StorageNoInstance, SortN) {
     ASSERT_EQ(pool.data()[1u], entity[0u]);
     ASSERT_EQ(pool.data()[2u], entity[2u]);
 
-    pool.sort_n(5u, std::less{});
+    pool.sort_n(5u, std::less{}); // NOLINT
 
     ASSERT_EQ(pool.data()[0u], entity[4u]);
     ASSERT_EQ(pool.data()[1u], entity[3u]);
@@ -614,7 +614,7 @@ TYPED_TEST(StorageNoInstance, SortAsDisjoint) {
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
 
     lhs.insert(std::begin(lhs_entity), std::end(lhs_entity));
 
@@ -630,8 +630,8 @@ TYPED_TEST(StorageNoInstance, SortAsOverlap) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
-    entt::entity rhs_entity[1u]{entt::entity{12}};
+    entt::entity lhs_entity[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}}; // NOLINT
+    entt::entity rhs_entity[1u]{entt::entity{12}};                                    // NOLINT
 
     lhs.insert(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.insert(std::begin(rhs_entity), std::end(rhs_entity));
@@ -651,8 +651,8 @@ TYPED_TEST(StorageNoInstance, SortAsOrdered) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}}; // NOLINT
 
     lhs.insert(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.insert(std::begin(rhs_entity), std::end(rhs_entity));
@@ -670,8 +670,8 @@ TYPED_TEST(StorageNoInstance, SortAsReverse) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}}; // NOLINT
 
     lhs.insert(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.insert(std::begin(rhs_entity), std::end(rhs_entity));
@@ -694,8 +694,8 @@ TYPED_TEST(StorageNoInstance, SortAsUnordered) {
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
 
-    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
-    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}};
+    entt::entity lhs_entity[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};                  // NOLINT
+    entt::entity rhs_entity[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}}; // NOLINT
 
     lhs.insert(std::begin(lhs_entity), std::end(lhs_entity));
     rhs.insert(std::begin(rhs_entity), std::end(rhs_entity));

test/entt/entity/view.cpp

@@ -168,13 +168,13 @@ TEST(SingleComponentView, ElementAccess) {
     auto cview = std::as_const(registry).view<const int>();
 
     const auto e0 = registry.create();
-    registry.emplace<int>(e0, 42);
+    registry.emplace<int>(e0, 42); // NOLINT
 
     const auto e1 = registry.create();
     registry.emplace<int>(e1, 3);
 
     for(auto i = 0u; i < view.size(); ++i) {
-        ASSERT_EQ(view[i], i ? e0 : e1); // NOLINT
+        ASSERT_EQ(view[i], i ? e0 : e1);  // NOLINT
         ASSERT_EQ(cview[i], i ? e0 : e1); // NOLINT
     }
 
@@ -210,7 +210,7 @@ TEST(SingleComponentView, Empty) {
 
 TEST(SingleComponentView, Each) {
     entt::registry registry;
-    const entt::entity entity[2]{registry.create(), registry.create()};
+    const entt::entity entity[2]{registry.create(), registry.create()}; // NOLINT
 
     auto view = registry.view<int>(entt::exclude<double>);
     auto cview = std::as_const(registry).view<const int>();
@@ -609,7 +609,7 @@ TEST(MultiComponentView, Functionalities) {
     registry.emplace<char>(e0, '1');
 
     const auto e1 = registry.create();
-    registry.emplace<int>(e1, 42);
+    registry.emplace<int>(e1, 42); // NOLINT
     registry.emplace<char>(e1, '2');
 
     ASSERT_EQ(*view.begin(), e1);
@@ -772,7 +772,7 @@ TEST(MultiComponentView, LazyExcludedTypeFromConstRegistry) {
 
 TEST(MultiComponentView, Iterator) {
     entt::registry registry;
-    const entt::entity entity[2]{registry.create(), registry.create()};
+    const entt::entity entity[2]{registry.create(), registry.create()}; // NOLINT
 
     registry.insert<int>(std::begin(entity), std::end(entity));
     registry.insert<char>(std::begin(entity), std::end(entity));
@@ -804,7 +804,7 @@ TEST(MultiComponentView, ElementAccess) {
     auto cview = std::as_const(registry).view<const int, const char>();
 
     const auto e0 = registry.create();
-    registry.emplace<int>(e0, 42);
+    registry.emplace<int>(e0, 42); // NOLINT
     registry.emplace<char>(e0, '0');
 
     const auto e1 = registry.create();
@@ -853,7 +853,7 @@ TEST(MultiComponentView, SizeHint) {
 
 TEST(MultiComponentView, UseAndRefresh) {
     entt::registry registry;
-    const entt::entity entity[3]{registry.create(), registry.create(), registry.create()};
+    const entt::entity entity[3]{registry.create(), registry.create(), registry.create()}; // NOLINT
 
     registry.emplace<int>(entity[0u]);
     registry.emplace<int>(entity[1u]);
@@ -883,7 +883,7 @@ TEST(MultiComponentView, UseAndRefresh) {
 
 TEST(MultiComponentView, Each) {
     entt::registry registry;
-    const entt::entity entity[2]{registry.create(), registry.create()};
+    const entt::entity entity[2]{registry.create(), registry.create()}; // NOLINT
 
     auto view = registry.view<int, char>(entt::exclude<double>);
     auto cview = std::as_const(registry).view<const int, const char>();
@@ -945,7 +945,7 @@ TEST(MultiComponentView, EachWithSuggestedType) {
 
     // makes char a better candidate during iterations
     const auto entity = registry.create();
-    registry.emplace<int>(entity, 99);
+    registry.emplace<int>(entity, 99); // NOLINT
 
     view.use<int>();
     view.each([value = 2](const auto curr, const auto) mutable {
@@ -1351,7 +1351,7 @@ TEST(MultiComponentView, StableTypeWithExcludedComponent) {
     const auto other = registry.create();
 
     registry.emplace<test::pointer_stable>(entity, 0);
-    registry.emplace<test::pointer_stable>(other, 42);
+    registry.emplace<test::pointer_stable>(other, 42); // NOLINT
     registry.emplace<int>(entity);
 
     ASSERT_EQ(view.size_hint(), 2u);
@@ -1396,8 +1396,8 @@ TEST(MultiComponentView, SameComponentTypes) {
     const entt::entity e0{42u};
     const entt::entity e1{3u};
 
-    storage.emplace(e0, 7);
-    other.emplace(e0, 9);
+    storage.emplace(e0, 7); // NOLINT
+    other.emplace(e0, 9);   // NOLINT
     other.emplace(e1, 1);
 
     ASSERT_TRUE(view.contains(e0));

test/entt/graph/flow.cpp

@@ -18,7 +18,7 @@ TEST(Flow, Constructors) {
 
     flow.bind(0);
     flow.bind(3);
-    flow.bind(99);
+    flow.bind(99); // NOLINT
 
     ASSERT_EQ(flow.size(), 3u);
 
@@ -38,7 +38,7 @@ TEST(Flow, Copy) {
 
     flow.bind(0);
     flow.bind(3);
-    flow.bind(99);
+    flow.bind(99); // NOLINT
 
     entt::flow other{flow};
 
@@ -68,7 +68,7 @@ TEST(Flow, Move) {
 
     flow.bind(0);
     flow.bind(3);
-    flow.bind(99);
+    flow.bind(99); // NOLINT
 
     entt::flow other{std::move(flow)};
 
@@ -95,7 +95,7 @@ TEST(Flow, Swap) {
     entt::flow flow{};
     entt::flow other{};
 
-    flow.bind(7);
+    flow.bind(7); // NOLINT
 
     ASSERT_EQ(other.size(), 0u);
     ASSERT_EQ(flow.size(), 1u);
@@ -112,7 +112,7 @@ TEST(Flow, Clear) {
     entt::flow flow{};
 
     flow.bind(0);
-    flow.bind(99);
+    flow.bind(99); // NOLINT
 
     ASSERT_EQ(flow.size(), 2u);
     ASSERT_EQ(flow[0u], 0u);
@@ -125,7 +125,7 @@ TEST(Flow, Clear) {
 
 TEST(Flow, Set) {
     entt::flow flow{};
-    flow.bind(0).set(10, true).bind(1).set(10, true).set(11, false);
+    flow.bind(0).set(10, true).bind(1).set(10, true).set(11, false); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -138,7 +138,7 @@ TEST(Flow, Set) {
 
 TEST(Flow, RO) {
     entt::flow flow{};
-    flow.bind(0).ro(10).bind(1).ro(10).ro(11);
+    flow.bind(0).ro(10).bind(1).ro(10).ro(11); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -148,8 +148,8 @@ TEST(Flow, RO) {
 
 TEST(Flow, RangeRO) {
     entt::flow flow{};
-    const entt::id_type res[2u]{10, 11};
-    flow.bind(0).ro(res, res + 1).bind(1).ro(res, res + 2);
+    const entt::id_type res[2u]{10, 11};                    // NOLINT
+    flow.bind(0).ro(res, res + 1).bind(1).ro(res, res + 2); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -159,7 +159,7 @@ TEST(Flow, RangeRO) {
 
 TEST(Flow, RW) {
     entt::flow flow{};
-    flow.bind(0).rw(10).bind(1).rw(10).rw(11);
+    flow.bind(0).rw(10).bind(1).rw(10).rw(11); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -172,8 +172,8 @@ TEST(Flow, RW) {
 
 TEST(Flow, RangeRW) {
     entt::flow flow{};
-    const entt::id_type res[2u]{10, 11};
-    flow.bind(0).rw(res, res + 1).bind(1).rw(res, res + 2);
+    const entt::id_type res[2u]{10, 11};                    // NOLINT
+    flow.bind(0).rw(res, res + 1).bind(1).rw(res, res + 2); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -288,7 +288,7 @@ ENTT_DEBUG_TEST(FlowDeathTest, NoBind) {
 
 TEST(Flow, DirectRebind) {
     entt::flow flow{};
-    flow.bind(0).ro(10).rw(10).bind(1).ro(10);
+    flow.bind(0).ro(10).rw(10).bind(1).ro(10); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -301,7 +301,7 @@ TEST(Flow, DirectRebind) {
 
 TEST(Flow, DeferredRebind) {
     entt::flow flow{};
-    flow.bind(0).ro(10).bind(1).ro(10).bind(0).rw(10);
+    flow.bind(0).ro(10).bind(1).ro(10).bind(0).rw(10); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);
@@ -314,7 +314,7 @@ TEST(Flow, DeferredRebind) {
 
 TEST(Flow, Loop) {
     entt::flow flow{};
-    flow.bind(0).rw(10).bind(1).ro(10).bind(0).rw(10);
+    flow.bind(0).rw(10).bind(1).ro(10).bind(0).rw(10); // NOLINT
     auto graph = flow.graph();
 
     ASSERT_EQ(flow.size(), 2u);

test/entt/locator/locator.cpp

@@ -68,7 +68,9 @@ TEST_F(ServiceLocator, ResetHandle) {
 
 TEST_F(ServiceLocator, ElementWithDeleter) {
     derived_service service{1};
-    entt::locator<base_service>::reset(&service, [](base_service *serv) { *static_cast<derived_service *>(serv) = derived_service{2}; });
+    entt::locator<base_service>::reset(&service, [](base_service *serv) {
+        *static_cast<derived_service *>(serv) = derived_service{2}; // NOLINT
+    });
 
     ASSERT_TRUE(entt::locator<base_service>::has_value());
     ASSERT_EQ(entt::locator<base_service>::value().invoke(1), 2);

test/entt/meta/meta_any.cpp

@@ -62,7 +62,7 @@ struct fat_t: empty_t {
         return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
     }
 
-    double value[4];
+    double value[4]; // NOLINT
 };
 
 enum class enum_class : unsigned short int {
@@ -72,7 +72,7 @@ enum class enum_class : unsigned short int {
 
 struct unmanageable_t {
     unmanageable_t()
-        : value{std::make_unique<int>(42)} {}
+        : value{std::make_unique<int>(42)} {} // NOLINT
 
     ~unmanageable_t() = default;
 
@@ -163,7 +163,7 @@ TEST_F(MetaAny, Empty) {
 }
 
 TEST_F(MetaAny, SBOInPlaceTypeConstruction) {
-    entt::meta_any any{std::in_place_type<int>, 42};
+    entt::meta_any any{std::in_place_type<int>, 42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(any.try_cast<std::size_t>());
@@ -176,7 +176,7 @@ TEST_F(MetaAny, SBOInPlaceTypeConstruction) {
 
 TEST_F(MetaAny, SBOAsRefConstruction) {
     int value = 3;
-    int compare = 42;
+    int compare = 42; // NOLINT
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
@@ -213,7 +213,7 @@ TEST_F(MetaAny, SBOAsRefConstruction) {
 
 TEST_F(MetaAny, SBOAsConstRefConstruction) {
     const int value = 3;
-    int compare = 42;
+    int compare = 42; // NOLINT
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
@@ -282,7 +282,7 @@ TEST_F(MetaAny, SBOCopyAssignment) {
 }
 
 TEST_F(MetaAny, SBOMoveConstruction) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     entt::meta_any other{std::move(any)};
 
     ASSERT_FALSE(any); // NOLINT
@@ -294,7 +294,7 @@ TEST_F(MetaAny, SBOMoveConstruction) {
 }
 
 TEST_F(MetaAny, SBOMoveAssignment) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     entt::meta_any other{3};
 
     other = std::move(any);
@@ -309,7 +309,7 @@ TEST_F(MetaAny, SBOMoveAssignment) {
 
 TEST_F(MetaAny, SBODirectAssignment) {
     entt::meta_any any{};
-    any = 42;
+    any = 42; // NOLINT
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
     ASSERT_EQ(any.cast<int>(), 42);
@@ -318,7 +318,7 @@ TEST_F(MetaAny, SBODirectAssignment) {
 }
 
 TEST_F(MetaAny, SBOAssignValue) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     const entt::meta_any other{3};
     const entt::meta_any invalid{empty_t{}};
 
@@ -331,7 +331,7 @@ TEST_F(MetaAny, SBOAssignValue) {
 }
 
 TEST_F(MetaAny, SBOConvertAssignValue) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     const entt::meta_any other{3.5};
     const entt::meta_any invalid{empty_t{}};
 
@@ -344,7 +344,7 @@ TEST_F(MetaAny, SBOConvertAssignValue) {
 }
 
 TEST_F(MetaAny, SBOAsRefAssignValue) {
-    int value = 42;
+    int value = 42; // NOLINT
     entt::meta_any any{entt::forward_as_meta(value)};
     const entt::meta_any other{3};
     const entt::meta_any invalid{empty_t{}};
@@ -374,7 +374,7 @@ TEST_F(MetaAny, SBOAsConstRefAssignValue) {
 }
 
 TEST_F(MetaAny, SBOTransferValue) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 42);
@@ -386,7 +386,7 @@ TEST_F(MetaAny, SBOTransferValue) {
 
 TEST_F(MetaAny, SBOTransferConstValue) {
     const int value = 3;
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 42);
@@ -396,7 +396,7 @@ TEST_F(MetaAny, SBOTransferConstValue) {
 }
 
 TEST_F(MetaAny, SBOConvertTransferValue) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 42);
@@ -407,7 +407,7 @@ TEST_F(MetaAny, SBOConvertTransferValue) {
 }
 
 TEST_F(MetaAny, SBOAsRefTransferValue) {
-    int value = 42;
+    int value = 42; // NOLINT
     entt::meta_any any{entt::forward_as_meta(value)};
 
     ASSERT_TRUE(any);
@@ -779,7 +779,7 @@ TEST_F(MetaAny, VoidMoveAssignment) {
 }
 
 TEST_F(MetaAny, SBOMoveInvalidate) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     entt::meta_any other{std::move(any)};
     const entt::meta_any valid = std::move(other);
 
@@ -842,7 +842,7 @@ TEST_F(MetaAny, VoidDestruction) {
 
 TEST_F(MetaAny, Emplace) {
     entt::meta_any any{};
-    any.emplace<int>(42);
+    any.emplace<int>(42); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(any.try_cast<std::size_t>());
@@ -864,7 +864,7 @@ TEST_F(MetaAny, EmplaceVoid) {
 }
 
 TEST_F(MetaAny, Reset) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -877,7 +877,7 @@ TEST_F(MetaAny, Reset) {
 
 TEST_F(MetaAny, SBOSwap) {
     entt::meta_any lhs{'c'};
-    entt::meta_any rhs{42};
+    entt::meta_any rhs{42}; // NOLINT
 
     std::swap(lhs, rhs);
 
@@ -975,7 +975,7 @@ TEST_F(MetaAny, NoSBOWithVoidSwap) {
 }
 
 TEST_F(MetaAny, AsRef) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     auto ref = any.as_ref();
     auto cref = std::as_const(any).as_ref();
 
@@ -1023,8 +1023,8 @@ TEST_F(MetaAny, AsRef) {
     ASSERT_EQ(ref.cast<const int &>(), 3);
     ASSERT_EQ(cref.cast<const int &>(), 3);
 
-    ref = 42;
-    cref = 42;
+    ref = 42;  // NOLINT
+    cref = 42; // NOLINT
 
     ASSERT_NE(ref.try_cast<int>(), nullptr);
     ASSERT_NE(cref.try_cast<int>(), nullptr);
@@ -1045,7 +1045,7 @@ TEST_F(MetaAny, AsRef) {
 }
 
 ENTT_DEBUG_TEST_F(MetaAnyDeathTest, AsRef) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
     auto cref = std::as_const(any).as_ref();
 
     ASSERT_TRUE(any);
@@ -1127,7 +1127,7 @@ TEST_F(MetaAny, Cast) {
 TEST_F(MetaAny, AllowCast) {
     entt::meta_any clazz{clazz_t{}};
     entt::meta_any fat{fat_t{}};
-    entt::meta_any arithmetic{42};
+    entt::meta_any arithmetic{42}; // NOLINT
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
     ASSERT_TRUE(clazz);
@@ -1185,7 +1185,7 @@ TEST_F(MetaAny, AllowCast) {
 TEST_F(MetaAny, OpaqueAllowCast) {
     entt::meta_any clazz{clazz_t{}};
     entt::meta_any fat{fat_t{}};
-    entt::meta_any arithmetic{42};
+    entt::meta_any arithmetic{42}; // NOLINT
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
     ASSERT_TRUE(clazz);
@@ -1235,7 +1235,7 @@ TEST_F(MetaAny, OpaqueAllowCast) {
 
 TEST_F(MetaAny, Convert) {
     entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().value = 42;
+    any.cast<clazz_t &>().value = 42; // NOLINT
     auto as_int = std::as_const(any).allow_cast<int>();
 
     ASSERT_TRUE(any);
@@ -1369,7 +1369,7 @@ TEST_F(MetaAny, SetGet) {
 }
 
 TEST_F(MetaAny, ForwardAsMeta) {
-    int value = 42;
+    int value = 42; // NOLINT
     auto ref = entt::forward_as_meta(value);
     auto cref = entt::forward_as_meta(std::as_const(value));
     auto any = entt::forward_as_meta(static_cast<int &&>(value));

test/entt/meta/meta_base.cpp

@@ -62,7 +62,7 @@ struct MetaBase: ::testing::Test {
 
 TEST_F(MetaBase, Functionalities) {
     auto any = entt::resolve<derived_t>().construct();
-    any.cast<derived_t &>().value_1 = 42;
+    any.cast<derived_t &>().value_1 = 42; // NOLINT
     auto as_derived = any.as_ref();
 
     ASSERT_TRUE(any.allow_cast<base_1_t &>());
@@ -120,7 +120,7 @@ TEST_F(MetaBase, ConvWithMutatingThis) {
     entt::meta_any any{derived_t{}};
     auto &&ref = any.cast<derived_t &>();
     auto as_cref = std::as_const(any).as_ref();
-    ref.value_2 = 42;
+    ref.value_2 = 42; // NOLINT
 
     auto conv = std::as_const(any).allow_cast<int>();
     auto from_cref = std::as_const(as_cref).allow_cast<int>();
@@ -140,7 +140,7 @@ TEST_F(MetaBase, ConvWithMutatingThis) {
 TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
     entt::meta_any any{derived_t{}};
     auto as_cref = std::as_const(any).as_ref();
-    any.cast<derived_t &>().value_2 = 42;
+    any.cast<derived_t &>().value_2 = 42; // NOLINT
 
     auto conv = std::as_const(any).allow_cast(entt::resolve<int>());
     auto from_cref = std::as_const(as_cref).allow_cast(entt::resolve<int>());
@@ -164,7 +164,7 @@ TEST_F(MetaBase, AssignWithMutatingThis) {
     entt::meta_any src{derived_t{}};
 
     dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 42;
+    src.cast<derived_t &>().value_2 = 42; // NOLINT
 
     ASSERT_TRUE(dst.assign(src));
     ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 42);
@@ -177,7 +177,7 @@ TEST_F(MetaBase, TransferWithMutatingThis) {
     entt::meta_any src{derived_t{}};
 
     dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 42;
+    src.cast<derived_t &>().value_2 = 42; // NOLINT
 
     ASSERT_TRUE(dst.assign(std::move(src)));
     ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 42);

test/entt/meta/meta_container.cpp

@@ -96,7 +96,7 @@ TEST(SequenceContainer, StdVector) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42);
+    ret = view.insert(cview.end(), 42); // NOLINT
 
     ASSERT_TRUE(ret);
     ASSERT_EQ(*ret, 42);
@@ -242,7 +242,7 @@ TEST(SequenceContainer, StdList) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42);
+    ret = view.insert(cview.end(), 42); // NOLINT
 
     ASSERT_TRUE(ret);
     ASSERT_EQ(*ret, 42);
@@ -297,7 +297,7 @@ TEST(SequenceContainer, StdDeque) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42);
+    ret = view.insert(cview.end(), 42); // NOLINT
 
     ASSERT_TRUE(ret);
     ASSERT_EQ(*ret, 42);
@@ -342,7 +342,7 @@ TEST(SequenceContainer, Constness) {
     ASSERT_EQ(view.size(), 0u);
     ASSERT_EQ(view.begin(), view.end());
 
-    vec.push_back(42);
+    vec.push_back(42); // NOLINT
 
     ASSERT_EQ(view.size(), 1u);
     ASSERT_NE(view.begin(), view.end());
@@ -387,7 +387,7 @@ TEST(SequenceContainer, FromConstAny) {
 }
 
 TEST(SequenceContainer, FromConstAnyRef) {
-    std::vector<int> vec{42};
+    std::vector<int> vec{42}; // NOLINT
     const entt::meta_any any = entt::forward_as_meta(vec);
     auto view = any.as_sequence_container();
 
@@ -397,7 +397,7 @@ TEST(SequenceContainer, FromConstAnyRef) {
 }
 
 TEST(SequenceContainer, FromConstAnyConstRef) {
-    std::vector<int> vec{42};
+    std::vector<int> vec{42}; // NOLINT
     const entt::meta_any any = entt::forward_as_meta(std::as_const(vec));
     auto view = any.as_sequence_container();
 
@@ -416,7 +416,7 @@ ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAny) {
 }
 
 ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyRef) {
-    std::vector<int> vec{42};
+    std::vector<int> vec{42}; // NOLINT
     const entt::meta_any any = entt::forward_as_meta(vec);
     auto view = any.as_sequence_container();
 
@@ -425,7 +425,7 @@ ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyRef) {
 }
 
 ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyConstRef) {
-    std::vector<int> vec{42};
+    std::vector<int> vec{42}; // NOLINT
     const entt::meta_any any = entt::forward_as_meta(std::as_const(vec));
     auto view = any.as_sequence_container();
 

test/entt/meta/meta_context.cpp

@@ -27,7 +27,8 @@ struct base {
 };
 
 struct clazz: base {
-    clazz() = default;
+    clazz()
+        : base{} {}
 
     clazz(int v)
         : base{},
@@ -196,7 +197,7 @@ TEST_F(MetaContext, MetaType) {
     ASSERT_EQ(global.id(), "foo"_hs);
     ASSERT_EQ(local.id(), "bar"_hs);
 
-    clazz instance{'c', 99};
+    clazz instance{'c', 99}; // NOLINT
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -242,7 +243,7 @@ TEST_F(MetaContext, MetaData) {
     ASSERT_EQ(global.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), global_marker);
     ASSERT_EQ(local.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), local_marker);
 
-    clazz instance{'c', 99};
+    clazz instance{'c', 99}; // NOLINT
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -277,7 +278,7 @@ TEST_F(MetaContext, MetaFunc) {
     ASSERT_EQ(global.func("func"_hs).ret().data("marker"_hs).get({}).cast<int>(), global_marker);
     ASSERT_EQ(local.func("func"_hs).ret().data("marker"_hs).get({}).cast<int>(), local_marker);
 
-    clazz instance{'c', 99};
+    clazz instance{'c', 99}; // NOLINT
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -392,7 +393,7 @@ TEST_F(MetaContext, MetaTemplate) {
 TEST_F(MetaContext, MetaPointer) {
     using namespace entt::literals;
 
-    int value = 42;
+    int value = 42; // NOLINT
 
     const entt::meta_any global{&value};
     const entt::meta_any local{ctx(), &value};
@@ -468,7 +469,7 @@ TEST_F(MetaContext, MetaAny) {
     ASSERT_TRUE(in_place);
     ASSERT_FALSE(two_step_local);
 
-    two_step_local = 42;
+    two_step_local = 42; // NOLINT
 
     ASSERT_TRUE(two_step_local);
 
@@ -481,7 +482,7 @@ TEST_F(MetaContext, MetaAny) {
 TEST_F(MetaContext, MetaHandle) {
     using namespace entt::literals;
 
-    int value = 42;
+    int value = 42; // NOLINT
 
     entt::meta_handle global{value};
     entt::meta_handle ctx_value{ctx(), value};

test/entt/meta/meta_conv.cpp

@@ -44,7 +44,7 @@ struct MetaConv: ::testing::Test {
 
 TEST_F(MetaConv, Functionalities) {
     auto any = entt::resolve<clazz_t>().construct();
-    any.cast<clazz_t &>().value = 42;
+    any.cast<clazz_t &>().value = 42; // NOLINT
 
     const auto as_int = std::as_const(any).allow_cast<int>();
     const auto as_bool = std::as_const(any).allow_cast<bool>();

test/entt/meta/meta_ctor.cpp

@@ -74,7 +74,7 @@ struct MetaCtor: ::testing::Test {
 };
 
 TEST_F(MetaCtor, Functionalities) {
-    auto any = entt::resolve<clazz_t>().construct(42, 'c');
+    auto any = entt::resolve<clazz_t>().construct(42, 'c'); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
@@ -82,7 +82,7 @@ TEST_F(MetaCtor, Functionalities) {
 }
 
 TEST_F(MetaCtor, Func) {
-    auto any = entt::resolve<clazz_t>().construct(42);
+    auto any = entt::resolve<clazz_t>().construct(42); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
@@ -90,7 +90,7 @@ TEST_F(MetaCtor, Func) {
 }
 
 TEST_F(MetaCtor, MetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42}, entt::meta_any{'c'});
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42}, entt::meta_any{'c'}); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
@@ -102,7 +102,7 @@ TEST_F(MetaCtor, InvalidArgs) {
 }
 
 TEST_F(MetaCtor, CastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{42, 'd'});
+    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{42, 'd'}); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
@@ -118,7 +118,7 @@ TEST_F(MetaCtor, ArithmeticConversion) {
 }
 
 TEST_F(MetaCtor, ConstNonConstRefArgs) {
-    int ivalue = 42;
+    int ivalue = 42; // NOLINT
     const char cvalue = 'c';
     auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
 
@@ -128,7 +128,7 @@ TEST_F(MetaCtor, ConstNonConstRefArgs) {
 }
 
 TEST_F(MetaCtor, WrongConstness) {
-    int value = 42;
+    int value = 42; // NOLINT
     auto any = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(value));
     auto other = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(std::as_const(value)));
 
@@ -139,7 +139,7 @@ TEST_F(MetaCtor, WrongConstness) {
 }
 
 TEST_F(MetaCtor, FuncMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42});
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42}); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
@@ -163,7 +163,7 @@ TEST_F(MetaCtor, FuncArithmeticConversion) {
 }
 
 TEST_F(MetaCtor, FuncConstNonConstRefArgs) {
-    int ivalue = 42;
+    int ivalue = 42; // NOLINT
     auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue));
     auto other = entt::resolve<clazz_t>().construct(entt::forward_as_meta(std::as_const(ivalue)));
 

test/entt/meta/meta_data.cpp

@@ -35,7 +35,7 @@ struct clazz_t {
     }
 
     int i{0};
-    const int j{1};
+    const int j{1}; // NOLINT
     base_t base{};
     inline static int h{2};       // NOLINT
     inline static const int k{3}; // NOLINT
@@ -83,7 +83,7 @@ struct multi_setter_t {
 
 struct array_t {
     inline static int global[3]; // NOLINT
-    int local[5];
+    int local[5];                // NOLINT
 };
 
 enum class property_t : entt::id_type {
@@ -277,7 +277,7 @@ TEST_F(MetaData, GetMetaAnyArg) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().i = 99;
+    any.cast<clazz_t &>().i = 99; // NOLINT
     const auto value = entt::resolve<clazz_t>().data("i"_hs).get(any);
 
     ASSERT_TRUE(value);
@@ -323,7 +323,7 @@ TEST_F(MetaData, SetConvert) {
     using namespace entt::literals;
 
     clazz_t instance{};
-    instance.h = 42;
+    instance.h = 42; // NOLINT
 
     ASSERT_EQ(instance.i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, instance));
@@ -334,7 +334,7 @@ TEST_F(MetaData, SetByRef) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    int value{42};
+    int value{42}; // NOLINT
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(value)));
@@ -351,7 +351,7 @@ TEST_F(MetaData, SetByConstRef) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    int value{42};
+    int value{42}; // NOLINT
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
@@ -526,8 +526,8 @@ TEST_F(MetaData, ArrayStatic) {
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
-    ASSERT_EQ(data.type(), entt::resolve<int[3]>());
-    ASSERT_EQ(data.arg(0u), entt::resolve<int[3]>());
+    ASSERT_EQ(data.type(), entt::resolve<int[3]>());  // NOLINT
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[3]>()); // NOLINT
     ASSERT_FALSE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_TRUE(data.type().is_array());
@@ -542,8 +542,8 @@ TEST_F(MetaData, Array) {
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
-    ASSERT_EQ(data.type(), entt::resolve<int[5]>());
-    ASSERT_EQ(data.arg(0u), entt::resolve<int[5]>());
+    ASSERT_EQ(data.type(), entt::resolve<int[5]>());  // NOLINT
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[5]>()); // NOLINT
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_TRUE(data.type().is_array());

test/entt/meta/meta_func.cpp

@@ -259,7 +259,7 @@ TEST_F(MetaFunc, RetVoid) {
     ASSERT_EQ(func.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(func.arg(1u));
 
-    auto any = func.invoke(instance, 5);
+    auto any = func.invoke(instance, 5); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
@@ -328,7 +328,7 @@ TEST_F(MetaFunc, StaticRetVoid) {
     ASSERT_EQ(func.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(func.arg(1u));
 
-    auto any = func.invoke({}, 42);
+    auto any = func.invoke({}, 42); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
@@ -353,7 +353,7 @@ TEST_F(MetaFunc, StaticAsMember) {
 
     base_t instance{};
     auto func = entt::resolve<base_t>().func("fake_member"_hs);
-    auto any = func.invoke(instance, 42);
+    auto any = func.invoke(instance, 42); // NOLINT
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -555,7 +555,7 @@ TEST_F(MetaFunc, InvokeBaseFunction) {
     ASSERT_TRUE(type.func("setter"_hs));
     ASSERT_EQ(instance.value, 3);
 
-    type.func("setter"_hs).invoke(instance, 42);
+    type.func("setter"_hs).invoke(instance, 42); // NOLINT
 
     ASSERT_EQ(instance.value, 42);
 }
@@ -571,7 +571,7 @@ TEST_F(MetaFunc, InvokeFromBase) {
     ASSERT_TRUE(setter_from_base);
     ASSERT_EQ(instance.value, 3);
 
-    setter_from_base.invoke(instance, 42);
+    setter_from_base.invoke(instance, 42); // NOLINT
 
     ASSERT_EQ(instance.value, 42);
 

test/entt/meta/meta_pointer.cpp

@@ -79,7 +79,7 @@ Type &dereference_meta_pointer_like(const adl_wrapped_shared_ptr<Type> &ptr) {
 }
 
 int test_function() {
-    return 42;
+    return 42; // NOLINT
 }
 
 TEST(MetaPointerLike, DereferenceOperatorInvalidType) {
@@ -125,7 +125,7 @@ ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstType) {
 }
 
 TEST(MetaPointerLike, DereferenceOperatorConstAnyNonConstType) {
-    int value = 42;
+    int value = 42; // NOLINT
     const entt::meta_any any{&value};
     auto deref = *any;
 
@@ -179,7 +179,7 @@ TEST(MetaPointerLike, DereferenceOperatorRawPointer) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42;
+    deref.cast<int &>() = 42; // NOLINT
 
     ASSERT_EQ(*any.cast<int *>(), 42);
     ASSERT_EQ(value, 42);
@@ -200,7 +200,7 @@ TEST(MetaPointerLike, DereferenceOperatorSmartPointer) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42;
+    deref.cast<int &>() = 42; // NOLINT
 
     ASSERT_EQ(*any.cast<std::shared_ptr<int>>(), 42);
     ASSERT_EQ(*value, 42);
@@ -235,14 +235,14 @@ TEST(MetaPointerLike, AsRef) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42;
+    deref.cast<int &>() = 42; // NOLINT
 
     ASSERT_EQ(*any.cast<int *>(), 42);
     ASSERT_EQ(value, 42);
 }
 
 TEST(MetaPointerLike, AsConstRef) {
-    int value = 42;
+    int value = 42; // NOLINT
     int *const ptr = &value;
     entt::meta_any any{entt::forward_as_meta(ptr)};
 
@@ -257,7 +257,7 @@ TEST(MetaPointerLike, AsConstRef) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42;
+    deref.cast<int &>() = 42; // NOLINT
 
     ASSERT_EQ(*any.cast<int *>(), 42);
     ASSERT_EQ(value, 42);
@@ -401,7 +401,7 @@ TEST(MetaPointerLike, DereferencePointerToFunction) {
 }
 
 TEST(MetaPointerLike, DereferenceSelfPointer) {
-    self_ptr obj{42};
+    self_ptr obj{42}; // NOLINT
     const entt::meta_any any{entt::forward_as_meta(obj)};
     entt::meta_any deref = *any;
 
@@ -422,17 +422,17 @@ TEST(MetaPointerLike, DereferenceProxyPointer) {
     ASSERT_EQ(*deref.cast<const proxy_ptr &>().value, value);
     ASSERT_TRUE(deref.try_cast<proxy_ptr>());
 
-    *deref.cast<proxy_ptr &>().value = 42;
+    *deref.cast<proxy_ptr &>().value = 42; // NOLINT
 
     ASSERT_EQ(value, 42);
 }
 
 TEST(MetaPointerLike, DereferenceArray) {
-    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]>};
+    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]>());
-    ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>());
+    ASSERT_EQ(array.type(), entt::resolve<int[3]>());             // NOLINT
+    ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>()); // NOLINT
 
     ASSERT_FALSE(*array);
     ASSERT_FALSE(*array_of_array);

test/entt/meta/meta_prop.cpp

@@ -19,7 +19,7 @@ struct MetaProp: ::testing::Test {
 
         entt::meta<base_1_t>()
             .type("base_1"_hs)
-            .prop("int"_hs, 42);
+            .prop("int"_hs, 42); // NOLINT
 
         entt::meta<base_2_t>()
             .type("base_2"_hs)
@@ -29,7 +29,7 @@ struct MetaProp: ::testing::Test {
         entt::meta<base_3_t>()
             .type("base_3"_hs)
             .prop("key_only"_hs)
-            .prop("key"_hs, 42);
+            .prop("key"_hs, 42); // NOLINT
 
         entt::meta<derived_t>()
             .type("derived"_hs)

test/entt/meta/meta_range.cpp

@@ -12,7 +12,7 @@ struct MetaRange: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<int>().type("int"_hs).data<42>("answer"_hs);
+        entt::meta<int>().type("int"_hs).data<42>("answer"_hs); // NOLINT
     }
 
     void TearDown() override {

test/entt/meta/meta_type.cpp

@@ -122,7 +122,7 @@ struct MetaType: ::testing::Test {
         entt::meta<unsigned int>()
             .type("unsigned int"_hs)
             .data<0u>("min"_hs)
-            .data<100u>("max"_hs);
+            .data<100u>("max"_hs); // NOLINT
 
         entt::meta<base_t>()
             .type("base"_hs)
@@ -172,7 +172,7 @@ struct MetaType: ::testing::Test {
 
         entt::meta<clazz_t>()
             .type("clazz"_hs)
-            .prop(static_cast<entt::id_type>(property_t::value), 42)
+            .prop(static_cast<entt::id_type>(property_t::value), 42) // NOLINT
             .ctor<const base_t &, int>()
             .data<&clazz_t::value>("value"_hs)
             .func<&clazz_t::member>("member"_hs)
@@ -237,8 +237,8 @@ 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);
-    ASSERT_EQ(entt::resolve<int[3]>().size_of(), sizeof(int[3]));
+    ASSERT_EQ(entt::resolve<int[]>().size_of(), 0u);              // NOLINT
+    ASSERT_EQ(entt::resolve<int[3]>().size_of(), sizeof(int[3])); // NOLINT
 }
 
 TEST_F(MetaType, Traits) {
@@ -254,8 +254,8 @@ 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());
-    ASSERT_TRUE(entt::resolve<int[5][3]>().is_array());
+    ASSERT_TRUE(entt::resolve<int[5]>().is_array());    // NOLINT
+    ASSERT_TRUE(entt::resolve<int[5][3]>().is_array()); // NOLINT
     ASSERT_FALSE(entt::resolve<int>().is_array());
 
     ASSERT_TRUE(entt::resolve<property_t>().is_enum());
@@ -442,21 +442,21 @@ TEST_F(MetaType, OverloadedFunc) {
     ASSERT_NE(res.try_cast<int>(), nullptr);
     ASSERT_EQ(res.cast<int>(), 16);
 
-    res = type.invoke("f"_hs, instance, 5);
+    res = type.invoke("f"_hs, instance, 5); // NOLINT
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 3);
     ASSERT_NE(res.try_cast<int>(), nullptr);
     ASSERT_EQ(res.cast<int>(), 50);
 
-    res = type.invoke("f"_hs, std::as_const(instance), 5);
+    res = type.invoke("f"_hs, std::as_const(instance), 5); // NOLINT
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 3);
     ASSERT_NE(res.try_cast<int>(), nullptr);
     ASSERT_EQ(res.cast<int>(), 25);
 
-    res = type.invoke("f"_hs, instance, 6, 7.f);
+    res = type.invoke("f"_hs, instance, 6, 7.f); // NOLINT
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 6);
@@ -475,7 +475,7 @@ TEST_F(MetaType, OverloadedFunc) {
 }
 
 TEST_F(MetaType, Construct) {
-    auto any = entt::resolve<clazz_t>().construct(base_t{}, 42);
+    auto any = entt::resolve<clazz_t>().construct(base_t{}, 42); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
@@ -489,7 +489,7 @@ TEST_F(MetaType, ConstructNoArgs) {
 }
 
 TEST_F(MetaType, ConstructMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{42});
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{42}); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
@@ -504,7 +504,7 @@ TEST_F(MetaType, LessArgs) {
 }
 
 TEST_F(MetaType, ConstructCastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 42});
+    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 42}); // NOLINT
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
@@ -610,7 +610,7 @@ TEST_F(MetaType, AbstractClass) {
     ASSERT_EQ(instance.base_t::value, 'c');
     ASSERT_EQ(instance.value, 3);
 
-    type.func("func"_hs).invoke(instance, 42);
+    type.func("func"_hs).invoke(instance, 42); // NOLINT
 
     ASSERT_EQ(instance.base_t::value, 'c');
     ASSERT_EQ(instance.value, 42);
@@ -739,7 +739,7 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     entt::meta<property_t>()
         .type("property"_hs)
         .data<property_t::random>("rand"_hs)
-        .prop(static_cast<entt::id_type>(property_t::value), 42)
+        .prop(static_cast<entt::id_type>(property_t::value), 42) // NOLINT
         .prop(static_cast<entt::id_type>(property_t::random), 3);
 
     ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::value)));

test/entt/meta/meta_utility.cpp

@@ -40,7 +40,7 @@ struct clazz {
     }
 
     int member{};
-    const int cmember{};
+    const int cmember{};              // NOLINT
     inline static int value{};        // NOLINT
     inline static const int cvalue{}; // NOLINT
     inline static int arr[3u]{};      // NOLINT
@@ -55,7 +55,7 @@ struct MetaUtility: ::testing::Test {
 using MetaUtilityDeathTest = MetaUtility;
 
 TEST_F(MetaUtility, MetaDispatch) {
-    int value = 42;
+    int value = 42; // NOLINT
 
     auto as_void = entt::meta_dispatch<entt::as_void_t>(value);
     auto as_ref = entt::meta_dispatch<entt::as_ref_t>(value);
@@ -78,7 +78,7 @@ TEST_F(MetaUtility, MetaDispatch) {
 }
 
 TEST_F(MetaUtility, MetaDispatchMetaAny) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     auto from_any = entt::meta_dispatch(any);
     auto from_const_any = entt::meta_dispatch(std::as_const(any));
@@ -94,7 +94,7 @@ TEST_F(MetaUtility, MetaDispatchMetaAny) {
 }
 
 TEST_F(MetaUtility, MetaDispatchMetaAnyAsRef) {
-    entt::meta_any any{42};
+    entt::meta_any any{42}; // NOLINT
 
     auto from_any = entt::meta_dispatch(any.as_ref());
     auto from_const_any = entt::meta_dispatch(std::as_const(any).as_ref());
@@ -187,14 +187,14 @@ TEST_F(MetaUtility, MetaGetter) {
 }
 
 TEST_F(MetaUtility, MetaInvokeWithCandidate) {
-    entt::meta_any args[2u]{clazz{}, 42};
-    args[0u].cast<clazz &>().value = 99;
+    entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
+    args[0u].cast<clazz &>().value = 99;  // NOLINT
 
     ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, nullptr)));
     ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::getter, nullptr)));
 
-    ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args + 1u)));
-    ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args)));
+    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_FALSE((entt::meta_invoke<clazz>(args[1u], &clazz::getter, nullptr)));
 
@@ -205,19 +205,19 @@ 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));
-    ASSERT_EQ(entt::meta_invoke<test::empty>({}, getter, args + 1u).cast<int>(), 6);
+    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
 }
 
 TEST_F(MetaUtility, MetaInvoke) {
-    entt::meta_any args[2u]{clazz{}, 42};
-    args[0u].cast<clazz &>().value = 99;
+    entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
+    args[0u].cast<clazz &>().value = 99;  // NOLINT
 
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, nullptr)));
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>({}, nullptr)));
 
-    ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args + 1u)));
-    ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args)));
+    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_FALSE((entt::meta_invoke<clazz, &clazz::getter>(args[1u], nullptr)));
 
@@ -227,42 +227,42 @@ TEST_F(MetaUtility, MetaInvoke) {
 }
 
 TEST_F(MetaUtility, MetaConstructArgsOnly) {
-    entt::meta_any args[2u]{clazz{}, 42};
-    const auto any = entt::meta_construct<clazz, int>(args + 1u);
+    entt::meta_any args[2u]{clazz{}, 42};                         // NOLINT
+    const auto any = entt::meta_construct<clazz, int>(args + 1u); // NOLINT
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct<clazz, int>(args)));
+    ASSERT_FALSE((entt::meta_construct<clazz, int>(args))); // NOLINT
     ASSERT_EQ(any.cast<const clazz &>().member, 42);
 }
 
 TEST_F(MetaUtility, MetaConstructWithCandidate) {
-    entt::meta_any args[2u]{clazz{}, 42};
-    const auto any = entt::meta_construct<clazz>(&clazz::factory, args + 1u);
+    entt::meta_any args[2u]{clazz{}, 42};                                     // NOLINT
+    const auto any = entt::meta_construct<clazz>(&clazz::factory, args + 1u); // NOLINT
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args)));
+    ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args))); // NOLINT
     ASSERT_EQ(any.cast<const clazz &>().member, 42);
 
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
-    ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args)));
+    ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args))); // NOLINT
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 42);
 
     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));
-    ASSERT_EQ(entt::meta_construct<test::empty>(builder, args + 1u).cast<int>(), 6);
+    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
 }
 
 TEST_F(MetaUtility, MetaConstruct) {
-    entt::meta_any args[2u]{clazz{}, 42};
-    const auto any = entt::meta_construct<clazz, &clazz::factory>(args + 1u);
+    entt::meta_any args[2u]{clazz{}, 42};                                     // NOLINT
+    const auto any = entt::meta_construct<clazz, &clazz::factory>(args + 1u); // NOLINT
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct<clazz, &clazz::factory>(args)));
+    ASSERT_FALSE((entt::meta_construct<clazz, &clazz::factory>(args))); // NOLINT
     ASSERT_EQ(any.cast<const clazz &>().member, 42);
 
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
-    ASSERT_TRUE((entt::meta_construct<clazz, &clazz::static_setter>(args)));
+    ASSERT_TRUE((entt::meta_construct<clazz, &clazz::static_setter>(args))); // NOLINT
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 42);
 }

test/entt/poly/poly.cpp

@@ -30,7 +30,7 @@ struct common_type: Base {
     }
 
     [[nodiscard]] int rand() const {
-        return static_cast<int>(entt::poly_call<5>(*this));
+        return static_cast<int>(entt::poly_call<5>(*this)); // NOLINT
     }
 };
 
@@ -48,7 +48,7 @@ struct common_members {
 namespace {
 
 [[nodiscard]] int absolutely_random() {
-    return 42;
+    return 42; // NOLINT
 }
 
 } // namespace
@@ -390,7 +390,7 @@ TYPED_TEST(Poly, SBOVsZeroedSBOSize) {
 
 TYPED_TEST(Poly, SboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    typename TestFixture::template type<alignment, alignment> sbo[2]{over_aligned{}, over_aligned{}};
+    typename TestFixture::template type<alignment, alignment> sbo[2]{over_aligned{}, over_aligned{}}; // NOLINT
     const auto *data = sbo[0].data();
 
     ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(sbo[0u].data()) % alignment) == 0u); // NOLINT
@@ -406,7 +406,7 @@ TYPED_TEST(Poly, SboAlignment) {
 
 TYPED_TEST(Poly, NoSboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    typename TestFixture::template type<alignment> nosbo[2]{over_aligned{}, over_aligned{}};
+    typename TestFixture::template type<alignment> nosbo[2]{over_aligned{}, over_aligned{}}; // NOLINT
     const auto *data = nosbo[0].data();
 
     ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(nosbo[0u].data()) % alignment) == 0u); // NOLINT

test/entt/process/process.cpp

@@ -248,7 +248,7 @@ TEST(ProcessAdaptor, Data) {
     int value = 0;
 
     auto lambda = [](std::uint64_t, void *data, auto resolve, auto) {
-        *static_cast<int *>(data) = 42;
+        *static_cast<int *>(data) = 42; // NOLINT
         resolve();
     };
 

test/entt/resource/resource_cache.cpp

@@ -50,7 +50,7 @@ TEST(ResourceCache, Functionalities) {
 
     ASSERT_FALSE(cache.contains("resource"_hs));
 
-    cache.load("resource"_hs, 42);
+    cache.load("resource"_hs, 42); // NOLINT
 
     ASSERT_FALSE(cache.empty());
     ASSERT_EQ(cache.size(), 1u);
@@ -81,7 +81,7 @@ TEST(ResourceCache, Constructors) {
     cache = entt::resource_cache<int>{std::allocator<int>{}};
     cache = entt::resource_cache<int>{entt::resource_loader<int>{}, std::allocator<float>{}};
 
-    cache.load("resource"_hs, 42u);
+    cache.load("resource"_hs, 42u); // NOLINT
 
     entt::resource_cache<int> temp{cache, cache.get_allocator()};
     const entt::resource_cache<int> other{std::move(temp), cache.get_allocator()};
@@ -94,15 +94,15 @@ TEST(ResourceCache, Copy) {
     using namespace entt::literals;
 
     entt::resource_cache<std::size_t> cache;
-    cache.load("resource"_hs, 42u);
+    cache.load("resource"_hs, 42u); // NOLINT
 
     entt::resource_cache<std::size_t> other{cache};
 
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_TRUE(other.contains("resource"_hs));
 
-    cache.load("foo"_hs, 99u);
-    cache.load("bar"_hs, 77u);
+    cache.load("foo"_hs, 99u); // NOLINT
+    cache.load("bar"_hs, 77u); // NOLINT
     other.load("quux"_hs, 0u);
     other = cache;
 
@@ -120,7 +120,7 @@ TEST(ResourceCache, Move) {
     using namespace entt::literals;
 
     entt::resource_cache<std::size_t> cache;
-    cache.load("resource"_hs, 42u);
+    cache.load("resource"_hs, 42u); // NOLINT
 
     entt::resource_cache<std::size_t> other{std::move(cache)};
 
@@ -128,8 +128,8 @@ TEST(ResourceCache, Move) {
     ASSERT_TRUE(other.contains("resource"_hs));
 
     cache = other;
-    cache.load("foo"_hs, 99u);
-    cache.load("bar"_hs, 77u);
+    cache.load("foo"_hs, 99u); // NOLINT
+    cache.load("bar"_hs, 77u); // NOLINT
     other.load("quux"_hs, 0u);
     other = std::move(cache);
 
@@ -154,7 +154,7 @@ TEST(ResourceCache, Iterator) {
     testing::StaticAssertTypeEq<iterator::reference, std::pair<entt::id_type, entt::resource<int>>>();
 
     entt::resource_cache<int> cache;
-    cache.load("resource"_hs, 42);
+    cache.load("resource"_hs, 42); // NOLINT
 
     iterator end{cache.begin()};
     iterator begin{};
@@ -209,7 +209,7 @@ TEST(ResourceCache, ConstIterator) {
     testing::StaticAssertTypeEq<iterator::reference, std::pair<entt::id_type, entt::resource<const int>>>();
 
     entt::resource_cache<int> cache;
-    cache.load("resource"_hs, 42);
+    cache.load("resource"_hs, 42); // NOLINT
 
     iterator cend{cache.cbegin()};
     iterator cbegin{};
@@ -258,7 +258,7 @@ TEST(ResourceCache, IteratorConversion) {
     using namespace entt::literals;
 
     entt::resource_cache<int> cache;
-    cache.load("resource"_hs, 42);
+    cache.load("resource"_hs, 42); // NOLINT
 
     const typename entt::resource_cache<int>::iterator it = cache.begin();
     typename entt::resource_cache<int>::const_iterator cit = it;
@@ -348,7 +348,7 @@ TEST(ResourceCache, Erase) {
     ASSERT_EQ((--cache.end())->first, 5u);
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {
-        if(next == 1u || next == 8u || next == 6u) {
+        if(next == 1u || next == 8u || next == 6u) { // NOLINT
             ASSERT_FALSE(cache.contains(static_cast<entt::id_type>(next)));
         } else {
             ASSERT_TRUE(cache.contains(static_cast<entt::id_type>(next)));
@@ -373,7 +373,7 @@ TEST(ResourceCache, Indexing) {
     ASSERT_FALSE(cache["resource"_hs]);
     ASSERT_FALSE(std::as_const(cache)["resource"_hs]);
 
-    cache.load("resource"_hs, 99);
+    cache.load("resource"_hs, 99); // NOLINT
 
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_EQ(std::as_const(cache)["resource"_hs], 99);
@@ -384,12 +384,12 @@ TEST(ResourceCache, LoaderDispatching) {
     using namespace entt::literals;
 
     entt::resource_cache<int, loader<int>> cache;
-    cache.force_load("resource"_hs, 99);
+    cache.force_load("resource"_hs, 99); // NOLINT
 
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_EQ(cache["resource"_hs], 99);
 
-    cache.force_load("resource"_hs, with_callback{}, []() { return std::make_shared<int>(42); });
+    cache.force_load("resource"_hs, with_callback{}, []() { return std::make_shared<int>(42); }); // NOLINT
 
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_EQ(cache["resource"_hs], 42);
@@ -404,7 +404,7 @@ TEST(ResourceCache, BrokenLoader) {
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_FALSE(cache["resource"_hs]);
 
-    cache.force_load("resource"_hs, 42);
+    cache.force_load("resource"_hs, 42); // NOLINT
 
     ASSERT_TRUE(cache.contains("resource"_hs));
     ASSERT_TRUE(cache["resource"_hs]);

test/entt/signal/delegate.cpp

@@ -34,7 +34,7 @@ struct delegate_functor {
     }
 
     static const int static_value = 3;
-    const int data_member = 42;
+    const int data_member = 42; // NOLINT
 };
 
 struct const_nonconst_noexcept {
@@ -55,7 +55,7 @@ struct const_nonconst_noexcept {
     }
 
     int u{};
-    const int v{};
+    const int v{}; // NOLINT
     mutable int cnt{0};
 };
 

test/entt/signal/dispatcher.cpp

@@ -39,8 +39,8 @@ TEST(Dispatcher, Functionalities) {
     ASSERT_EQ(dispatcher.size<an_event>(), 0u);
     ASSERT_EQ(dispatcher.size(), 0u);
 
-    dispatcher.trigger(one_more_event{42});
-    dispatcher.enqueue<one_more_event>(42);
+    dispatcher.trigger(one_more_event{42}); // NOLINT
+    dispatcher.enqueue<one_more_event>(42); // NOLINT
     dispatcher.update<one_more_event>();
 
     dispatcher.sink<an_event>().connect<&receiver::receive>(receiver);

test/entt/signal/emitter.cpp

@@ -48,13 +48,13 @@ TEST(Emitter, Swap) {
     ASSERT_TRUE(other.empty());
 
     emitter.swap(other);
-    emitter.publish(foo_event{42});
+    emitter.publish(foo_event{42}); // NOLINT
 
     ASSERT_EQ(value, 0);
     ASSERT_TRUE(emitter.empty());
     ASSERT_FALSE(other.empty());
 
-    other.publish(foo_event{42});
+    other.publish(foo_event{42}); // NOLINT
 
     ASSERT_EQ(value, 42);
 }
@@ -136,7 +136,7 @@ TEST(Emitter, On) {
     ASSERT_TRUE(emitter.contains<foo_event>());
     ASSERT_EQ(value, 0);
 
-    emitter.publish(foo_event{42});
+    emitter.publish(foo_event{42}); // NOLINT
 
     ASSERT_EQ(value, 42);
 }

test/entt/signal/sigh.cpp

@@ -5,7 +5,7 @@
 
 struct sigh_listener {
     static void f(int &v) {
-        v = 42;
+        v = 42; // NOLINT
     }
 
     [[nodiscard]] bool g(int) {
@@ -166,14 +166,14 @@ TEST(SigH, Members) {
     entt::sink sink{sigh};
 
     sink.connect<&sigh_listener::g>(l1);
-    sigh.publish(42);
+    sigh.publish(42); // NOLINT
 
     ASSERT_TRUE(l1.val);
     ASSERT_FALSE(sigh.empty());
     ASSERT_EQ(1u, sigh.size());
 
     sink.disconnect<&sigh_listener::g>(l1);
-    sigh.publish(42);
+    sigh.publish(42); // NOLINT
 
     ASSERT_TRUE(l1.val);
     ASSERT_TRUE(sigh.empty());
@@ -212,7 +212,7 @@ TEST(SigH, Collector) {
     };
 
     listener.val = true;
-    sigh.collect(std::move(no_return), 42);
+    sigh.collect(std::move(no_return), 42); // NOLINT
 
     ASSERT_FALSE(sigh.empty());
     ASSERT_EQ(cnt, 2);
@@ -225,7 +225,7 @@ TEST(SigH, Collector) {
     };
 
     cnt = 0;
-    sigh.collect(std::move(bool_return), 42);
+    sigh.collect(std::move(bool_return), 42); // NOLINT
 
     ASSERT_EQ(cnt, 1);
 }
@@ -238,13 +238,13 @@ TEST(SigH, CollectorVoid) {
 
     sink.connect<&sigh_listener::g>(&listener);
     sink.connect<&sigh_listener::h>(listener);
-    sigh.collect([&cnt]() { ++cnt; }, 42);
+    sigh.collect([&cnt]() { ++cnt; }, 42); // NOLINT
 
     ASSERT_FALSE(sigh.empty());
     ASSERT_EQ(cnt, 2);
 
     cnt = 0;
-    sigh.collect([&cnt]() { ++cnt; return true; }, 42);
+    sigh.collect([&cnt]() { ++cnt; return true; }, 42); // NOLINT
 
     ASSERT_EQ(cnt, 1);
 }
@@ -279,14 +279,14 @@ TEST(SigH, ScopedConnection) {
         ASSERT_FALSE(listener.val);
 
         const entt::scoped_connection conn = sink.connect<&sigh_listener::g>(listener);
-        sigh.publish(42);
+        sigh.publish(42); // NOLINT
 
         ASSERT_FALSE(sigh.empty());
         ASSERT_TRUE(listener.val);
         ASSERT_TRUE(conn);
     }
 
-    sigh.publish(42);
+    sigh.publish(42); // NOLINT
 
     ASSERT_TRUE(sigh.empty());
     ASSERT_TRUE(listener.val);
@@ -309,7 +309,7 @@ TEST(SigH, ScopedConnectionMove) {
         ASSERT_FALSE(outer); // NOLINT
         ASSERT_TRUE(inner);
 
-        sigh.publish(42);
+        sigh.publish(42); // NOLINT
 
         ASSERT_TRUE(listener.val);
     }
@@ -333,7 +333,7 @@ TEST(SigH, ScopedConnectionMove) {
         ASSERT_FALSE(outer); // NOLINT
         ASSERT_TRUE(inner);
 
-        sigh.publish(42);
+        sigh.publish(42); // NOLINT
 
         ASSERT_FALSE(listener.val);
     }
@@ -354,7 +354,7 @@ TEST(SigH, ScopedConnectionConstructorsAndOperators) {
         ASSERT_FALSE(inner);
 
         inner = sink.connect<&sigh_listener::g>(listener);
-        sigh.publish(42);
+        sigh.publish(42); // NOLINT
 
         ASSERT_FALSE(sigh.empty());
         ASSERT_TRUE(listener.val);
@@ -367,14 +367,14 @@ TEST(SigH, ScopedConnectionConstructorsAndOperators) {
 
         auto basic = sink.connect<&sigh_listener::g>(listener);
         inner = std::as_const(basic);
-        sigh.publish(42);
+        sigh.publish(42); // NOLINT
 
         ASSERT_FALSE(sigh.empty());
         ASSERT_FALSE(listener.val);
         ASSERT_TRUE(inner);
     }
 
-    sigh.publish(42);
+    sigh.publish(42); // NOLINT
 
     ASSERT_TRUE(sigh.empty());
     ASSERT_FALSE(listener.val);
@@ -426,7 +426,7 @@ TEST(SigH, UnboundMemberFunction) {
     ASSERT_FALSE(listener.val);
 
     sink.connect<&sigh_listener::g>();
-    sigh.publish(&listener, 42);
+    sigh.publish(&listener, 42); // NOLINT
 
     ASSERT_TRUE(listener.val);
 }

test/example/custom_identifier.cpp

@@ -41,10 +41,10 @@ TEST(Example, CustomIdentifier) {
     ASSERT_FALSE((registry.all_of<int, char>(entity)));
     ASSERT_EQ(registry.try_get<int>(entity), nullptr);
 
-    registry.emplace<int>(entity, 42);
+    registry.emplace<int>(entity, 42); // NOLINT
 
     ASSERT_TRUE((registry.any_of<int, char>(entity)));
-    ASSERT_EQ(registry.get<int>(entity), 42);
+    ASSERT_EQ(registry.get<int>(entity), 42); // NOLINT
 
     registry.destroy(entity);
 

test/example/entity_copy.cpp

@@ -54,7 +54,7 @@ TEST(EntityCopy, SameRegistry) {
     const auto dst = registry.create();
 
     custom.emplace(src, 1.);
-    registry.emplace<int>(src, 42);
+    registry.emplace<int>(src, 42); // NOLINT
     registry.emplace<char>(src, 'c');
 
     ASSERT_EQ(registry.storage<entt::entity>().size(), 2u);
@@ -90,7 +90,7 @@ TYPED_TEST(EntityCopy, CrossRegistry) {
     const auto entity = src.create();
     const auto copy = dst.create();
 
-    src.emplace<int>(entity, 42);
+    src.emplace<int>(entity, 42); // NOLINT
     src.emplace<char>(entity, 'c');
 
     ASSERT_EQ(src.storage<entt::entity>().size(), 1u);

test/example/signal_less.cpp

@@ -39,8 +39,8 @@ TEST(Example, SignalLess) {
     // literally a test for storage_adapter_mixin
     registry.emplace<int>(entity[0], 0);
     registry.erase<int>(entity[0]);
-    registry.insert<int>(std::begin(entity), std::end(entity), 3);
-    registry.patch<int>(entity[0], [](auto &value) { value = 42; });
+    registry.insert<int>(std::begin(entity), std::end(entity), 3);   // NOLINT
+    registry.patch<int>(entity[0], [](auto &value) { value = 42; }); // NOLINT
 
-    ASSERT_EQ(registry.get<int>(entity[0]), 42);
+    ASSERT_EQ(registry.get<int>(entity[0]), 42); // NOLINT
 }

test/lib/dispatcher/shared/lib.cpp

@@ -4,5 +4,5 @@
 
 ENTT_API void trigger(entt::dispatcher &dispatcher) {
     dispatcher.trigger<event>();
-    dispatcher.trigger(message{42});
+    dispatcher.trigger(message{42}); // NOLINT
 }

test/lib/emitter/shared/lib.cpp

@@ -3,6 +3,6 @@
 
 ENTT_API void emit(test_emitter &emitter) {
     emitter.publish(event{});
-    emitter.publish(message{42});
-    emitter.publish(message{3});
+    emitter.publish(message{42}); // NOLINT
+    emitter.publish(message{3});  // NOLINT
 }