test: avoid using deprecated functions

test/entt/entity/sigh_mixin.cpp

@@ -411,8 +411,8 @@ TYPED_TEST(SighMixin, Swap) {
     ASSERT_EQ(pool.size(), 1u + traits_type::in_place_delete);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3}); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{42});                         // NOLINT
+    ASSERT_EQ(pool.index(entt::entity{3}), traits_type::in_place_delete);
+    ASSERT_EQ(other.index(entt::entity{42}), 0u);
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{2});
     ASSERT_EQ(other.get(entt::entity{42}), value_type{41});
@@ -620,8 +620,8 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_TRUE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
-    ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
+    ASSERT_EQ(pool.index(entity[0u]), 1u);
+    ASSERT_EQ(pool.index(entity[1u]), 0u);
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
     ASSERT_EQ(pool.get(entity[1u]), value[0u]);
@@ -632,7 +632,7 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_FALSE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[0u]); // NOLINT
+    ASSERT_EQ(pool.index(entity[0u]), 0u);
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
 
     ASSERT_EQ(on_construct, 2u);

test/entt/entity/sparse_set.cpp

@@ -171,8 +171,8 @@ TYPED_TEST(SparseSet, Swap) {
         ASSERT_EQ(set.size(), 2u);
         ASSERT_EQ(other.size(), 1u);
 
-        ASSERT_EQ(set.at(1u), entity_type{3});    // NOLINT
-        ASSERT_EQ(other.at(0u), entity_type{42}); // NOLINT
+        ASSERT_EQ(set.index(entity_type{3}), 1u);
+        ASSERT_EQ(other.index(entity_type{42}), 0u);
     }
 }
 
@@ -1053,8 +1053,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1063,8 +1063,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1072,8 +1072,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(std::begin(entity), std::end(entity)), entity[0u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1087,8 +1087,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1097,8 +1097,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(entity[1u]), entity[1u]);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[1u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[0u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 1u);
+            ASSERT_EQ(set.index(entity[1u]), 0u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1106,8 +1106,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(*set.push(std::begin(entity), std::end(entity)), entity[0u]);
             ASSERT_EQ(set.size(), 4u);
 
-            ASSERT_EQ(set.at(2u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(3u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 2u);
+            ASSERT_EQ(set.index(entity[1u]), 3u);
 
             set.erase(std::begin(entity), std::end(entity));
             set.compact();
@@ -1124,8 +1124,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1136,8 +1136,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 
@@ -1147,8 +1147,8 @@ TYPED_TEST(SparseSet, Push) {
             ASSERT_EQ(set.free_list(), 2u);
             ASSERT_EQ(set.size(), 2u);
 
-            ASSERT_EQ(set.at(0u), entity[0u]); // NOLINT
-            ASSERT_EQ(set.at(1u), entity[1u]); // NOLINT
+            ASSERT_EQ(set.index(entity[0u]), 0u);
+            ASSERT_EQ(set.index(entity[1u]), 1u);
 
             set.erase(std::begin(entity), std::end(entity));
 

test/entt/entity/storage.cpp

@@ -186,8 +186,8 @@ TYPED_TEST(Storage, Swap) {
     ASSERT_EQ(pool.size(), 1u + traits_type::in_place_delete);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(traits_type::in_place_delete), entt::entity{3}); // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{42});                         // NOLINT
+    ASSERT_EQ(pool.index(entt::entity{3}), traits_type::in_place_delete);
+    ASSERT_EQ(other.index(entt::entity{42}), 0u);
 
     ASSERT_EQ(pool.get(entt::entity{3}), value_type{2});
     ASSERT_EQ(other.get(entt::entity{42}), value_type{41});
@@ -841,14 +841,10 @@ TYPED_TEST(Storage, Insert) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 4u);
-        ASSERT_EQ(pool.at(2u), entity[1u]); // NOLINT
-        ASSERT_EQ(pool.at(3u), entity[0u]); // NOLINT
         ASSERT_EQ(pool.index(entity[0u]), 3u);
         ASSERT_EQ(pool.index(entity[1u]), 2u);
     } else {
         ASSERT_EQ(pool.size(), 2u);
-        ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
-        ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
         ASSERT_EQ(pool.index(entity[0u]), 1u);
         ASSERT_EQ(pool.index(entity[1u]), 0u);
     }
@@ -872,7 +868,7 @@ TYPED_TEST(Storage, Erase) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 3u);
-        ASSERT_TRUE(pool.at(2u) == entt::tombstone); // NOLINT
+        ASSERT_TRUE(pool.data()[2u] == entt::tombstone);
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -893,7 +889,7 @@ TYPED_TEST(Storage, Erase) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 6u);
-        ASSERT_TRUE(pool.at(5u) == entt::tombstone); // NOLINT
+        ASSERT_TRUE(pool.data()[5u] == entt::tombstone);
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -931,7 +927,7 @@ TYPED_TEST(Storage, Remove) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 3u);
-        ASSERT_TRUE(pool.at(2u) == entt::tombstone); // NOLINT
+        ASSERT_TRUE(pool.data()[2u] == entt::tombstone);
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -953,7 +949,7 @@ TYPED_TEST(Storage, Remove) {
 
     if constexpr(traits_type::in_place_delete) {
         ASSERT_EQ(pool.size(), 6u);
-        ASSERT_TRUE(pool.at(5u) == entt::tombstone); // NOLINT
+        ASSERT_TRUE(pool.data()[5u] == entt::tombstone);
     } else {
         ASSERT_EQ(pool.size(), 0u);
     }
@@ -1833,8 +1829,8 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_TRUE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[1u]); // NOLINT
-    ASSERT_EQ(pool.at(1u), entity[0u]); // NOLINT
+    ASSERT_EQ(pool.index(entity[0u]), 1u);
+    ASSERT_EQ(pool.index(entity[1u]), 0u);
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
     ASSERT_EQ(pool.get(entity[1u]), value[0u]);
@@ -1845,7 +1841,7 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_TRUE(pool.contains(entity[0u]));
     ASSERT_FALSE(pool.contains(entity[1u]));
-    ASSERT_EQ(pool.at(0u), entity[0u]); // NOLINT
+    ASSERT_EQ(pool.index(entity[0u]), 0u);
     ASSERT_EQ(pool.get(entity[0u]), value[1u]);
 }
 

test/entt/entity/storage_entity.cpp

@@ -108,8 +108,8 @@ TEST(StorageEntity, Swap) {
     ASSERT_EQ(pool.size(), 10u);
     ASSERT_EQ(other.size(), 43u);
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});   // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{42}); // NOLINT
+    ASSERT_EQ(pool.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entt::entity{42}), 0u);
 }
 
 TEST(StorageEntity, Getters) {

test/entt/entity/storage_no_instance.cpp

@@ -152,8 +152,8 @@ TYPED_TEST(StorageNoInstance, Swap) {
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(other.size(), 1u);
 
-    ASSERT_EQ(pool.at(0u), entt::entity{3});   // NOLINT
-    ASSERT_EQ(other.at(0u), entt::entity{42}); // NOLINT
+    ASSERT_EQ(pool.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entt::entity{42}), 0u);
 }
 
 TYPED_TEST(StorageNoInstance, Getters) {