test: name consistency

test/entt/entity/group.cpp

@@ -985,30 +985,30 @@ TEST(OwningGroup, SortOrdered) {
     entt::registry registry;
     auto group = registry.group<boxed_int, char>();
 
-    entt::entity entities[5]{};
-    registry.create(std::begin(entities), std::end(entities));
+    entt::entity entity[5]{};
+    registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<boxed_int>(entities[0], 12);
-    registry.emplace<char>(entities[0], 'a');
+    registry.emplace<boxed_int>(entity[0], 12);
+    registry.emplace<char>(entity[0], 'a');
 
-    registry.emplace<boxed_int>(entities[1], 9);
-    registry.emplace<char>(entities[1], 'b');
+    registry.emplace<boxed_int>(entity[1], 9);
+    registry.emplace<char>(entity[1], 'b');
 
-    registry.emplace<boxed_int>(entities[2], 6);
-    registry.emplace<char>(entities[2], 'c');
+    registry.emplace<boxed_int>(entity[2], 6);
+    registry.emplace<char>(entity[2], 'c');
 
-    registry.emplace<boxed_int>(entities[3], 1);
-    registry.emplace<boxed_int>(entities[4], 2);
+    registry.emplace<boxed_int>(entity[3], 1);
+    registry.emplace<boxed_int>(entity[4], 2);
 
     group.sort([&group](const entt::entity lhs, const entt::entity rhs) {
         return group.get<boxed_int>(lhs).value < group.get<0>(rhs).value;
     });
 
-    ASSERT_EQ(group.handle().data()[0u], entities[0]);
-    ASSERT_EQ(group.handle().data()[1u], entities[1]);
-    ASSERT_EQ(group.handle().data()[2u], entities[2]);
-    ASSERT_EQ(group.handle().data()[3u], entities[3]);
-    ASSERT_EQ(group.handle().data()[4u], entities[4]);
+    ASSERT_EQ(group.handle().data()[0u], entity[0]);
+    ASSERT_EQ(group.handle().data()[1u], entity[1]);
+    ASSERT_EQ(group.handle().data()[2u], entity[2]);
+    ASSERT_EQ(group.handle().data()[3u], entity[3]);
+    ASSERT_EQ(group.handle().data()[4u], entity[4]);
 
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][1u].value, 9);
@@ -1020,42 +1020,42 @@ TEST(OwningGroup, SortOrdered) {
     ASSERT_EQ(group.storage<char>()->raw()[0u][1u], 'b');
     ASSERT_EQ(group.storage<char>()->raw()[0u][2u], 'c');
 
-    ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{12}, 'a')));
-    ASSERT_EQ((group.get<0, 1>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
-    ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{6}, 'c')));
+    ASSERT_EQ((group.get<boxed_int, char>(entity[0])), (std::make_tuple(boxed_int{12}, 'a')));
+    ASSERT_EQ((group.get<0, 1>(entity[1])), (std::make_tuple(boxed_int{9}, 'b')));
+    ASSERT_EQ((group.get<boxed_int, char>(entity[2])), (std::make_tuple(boxed_int{6}, 'c')));
 
-    ASSERT_FALSE(group.contains(entities[3]));
-    ASSERT_FALSE(group.contains(entities[4]));
+    ASSERT_FALSE(group.contains(entity[3]));
+    ASSERT_FALSE(group.contains(entity[4]));
 }
 
 TEST(OwningGroup, SortReverse) {
     entt::registry registry;
     auto group = registry.group<boxed_int, char>();
 
-    entt::entity entities[5]{};
-    registry.create(std::begin(entities), std::end(entities));
+    entt::entity entity[5]{};
+    registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<boxed_int>(entities[0], 6);
-    registry.emplace<char>(entities[0], 'a');
+    registry.emplace<boxed_int>(entity[0], 6);
+    registry.emplace<char>(entity[0], 'a');
 
-    registry.emplace<boxed_int>(entities[1], 9);
-    registry.emplace<char>(entities[1], 'b');
+    registry.emplace<boxed_int>(entity[1], 9);
+    registry.emplace<char>(entity[1], 'b');
 
-    registry.emplace<boxed_int>(entities[2], 12);
-    registry.emplace<char>(entities[2], 'c');
+    registry.emplace<boxed_int>(entity[2], 12);
+    registry.emplace<char>(entity[2], 'c');
 
-    registry.emplace<boxed_int>(entities[3], 1);
-    registry.emplace<boxed_int>(entities[4], 2);
+    registry.emplace<boxed_int>(entity[3], 1);
+    registry.emplace<boxed_int>(entity[4], 2);
 
     group.sort<boxed_int>([](const auto &lhs, const auto &rhs) {
         return lhs.value < rhs.value;
     });
 
-    ASSERT_EQ(group.handle().data()[0u], entities[2]);
-    ASSERT_EQ(group.handle().data()[1u], entities[1]);
-    ASSERT_EQ(group.handle().data()[2u], entities[0]);
-    ASSERT_EQ(group.handle().data()[3u], entities[3]);
-    ASSERT_EQ(group.handle().data()[4u], entities[4]);
+    ASSERT_EQ(group.handle().data()[0u], entity[2]);
+    ASSERT_EQ(group.handle().data()[1u], entity[1]);
+    ASSERT_EQ(group.handle().data()[2u], entity[0]);
+    ASSERT_EQ(group.handle().data()[3u], entity[3]);
+    ASSERT_EQ(group.handle().data()[4u], entity[4]);
 
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][1u].value, 9);
@@ -1067,38 +1067,38 @@ TEST(OwningGroup, SortReverse) {
     ASSERT_EQ(group.storage<char>()->raw()[0u][1u], 'b');
     ASSERT_EQ(group.storage<char>()->raw()[0u][2u], 'a');
 
-    ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{6}, 'a')));
-    ASSERT_EQ((group.get<0, 1>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
-    ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{12}, 'c')));
+    ASSERT_EQ((group.get<boxed_int, char>(entity[0])), (std::make_tuple(boxed_int{6}, 'a')));
+    ASSERT_EQ((group.get<0, 1>(entity[1])), (std::make_tuple(boxed_int{9}, 'b')));
+    ASSERT_EQ((group.get<boxed_int, char>(entity[2])), (std::make_tuple(boxed_int{12}, 'c')));
 
-    ASSERT_FALSE(group.contains(entities[3]));
-    ASSERT_FALSE(group.contains(entities[4]));
+    ASSERT_FALSE(group.contains(entity[3]));
+    ASSERT_FALSE(group.contains(entity[4]));
 }
 
 TEST(OwningGroup, SortUnordered) {
     entt::registry registry;
     auto group = registry.group<boxed_int>(entt::get<char>);
 
-    entt::entity entities[7]{};
-    registry.create(std::begin(entities), std::end(entities));
+    entt::entity entity[7]{};
+    registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<boxed_int>(entities[0], 6);
-    registry.emplace<char>(entities[0], 'c');
+    registry.emplace<boxed_int>(entity[0], 6);
+    registry.emplace<char>(entity[0], 'c');
 
-    registry.emplace<boxed_int>(entities[1], 3);
-    registry.emplace<char>(entities[1], 'b');
+    registry.emplace<boxed_int>(entity[1], 3);
+    registry.emplace<char>(entity[1], 'b');
 
-    registry.emplace<boxed_int>(entities[2], 1);
-    registry.emplace<char>(entities[2], 'a');
+    registry.emplace<boxed_int>(entity[2], 1);
+    registry.emplace<char>(entity[2], 'a');
 
-    registry.emplace<boxed_int>(entities[3], 9);
-    registry.emplace<char>(entities[3], 'd');
+    registry.emplace<boxed_int>(entity[3], 9);
+    registry.emplace<char>(entity[3], 'd');
 
-    registry.emplace<boxed_int>(entities[4], 12);
-    registry.emplace<char>(entities[4], 'e');
+    registry.emplace<boxed_int>(entity[4], 12);
+    registry.emplace<char>(entity[4], 'e');
 
-    registry.emplace<boxed_int>(entities[5], 4);
-    registry.emplace<boxed_int>(entities[6], 5);
+    registry.emplace<boxed_int>(entity[5], 4);
+    registry.emplace<boxed_int>(entity[6], 5);
 
     group.sort<boxed_int, char>([](const auto lhs, const auto rhs) {
         static_assert(std::is_same_v<decltype(std::get<0>(lhs)), boxed_int &>);
@@ -1106,13 +1106,13 @@ TEST(OwningGroup, SortUnordered) {
         return std::get<1>(lhs) < std::get<1>(rhs);
     });
 
-    ASSERT_EQ(group.handle().data()[0u], entities[4]);
-    ASSERT_EQ(group.handle().data()[1u], entities[3]);
-    ASSERT_EQ(group.handle().data()[2u], entities[0]);
-    ASSERT_EQ(group.handle().data()[3u], entities[1]);
-    ASSERT_EQ(group.handle().data()[4u], entities[2]);
-    ASSERT_EQ(group.handle().data()[5u], entities[5]);
-    ASSERT_EQ(group.handle().data()[6u], entities[6]);
+    ASSERT_EQ(group.handle().data()[0u], entity[4]);
+    ASSERT_EQ(group.handle().data()[1u], entity[3]);
+    ASSERT_EQ(group.handle().data()[2u], entity[0]);
+    ASSERT_EQ(group.handle().data()[3u], entity[1]);
+    ASSERT_EQ(group.handle().data()[4u], entity[2]);
+    ASSERT_EQ(group.handle().data()[5u], entity[5]);
+    ASSERT_EQ(group.handle().data()[6u], entity[6]);
 
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][1u].value, 9);
@@ -1128,45 +1128,45 @@ TEST(OwningGroup, SortUnordered) {
     ASSERT_EQ(group.get<1>(group.handle().data()[3u]), 'b');
     ASSERT_EQ(group.get<char>(group.handle().data()[4u]), 'a');
 
-    ASSERT_FALSE(group.contains(entities[5]));
-    ASSERT_FALSE(group.contains(entities[6]));
+    ASSERT_FALSE(group.contains(entity[5]));
+    ASSERT_FALSE(group.contains(entity[6]));
 }
 
 TEST(OwningGroup, SortWithExclusionList) {
     entt::registry registry;
     auto group = registry.group<boxed_int>(entt::get<>, entt::exclude<char>);
 
-    entt::entity entities[5]{};
-    registry.create(std::begin(entities), std::end(entities));
+    entt::entity entity[5]{};
+    registry.create(std::begin(entity), std::end(entity));
 
-    registry.emplace<boxed_int>(entities[0], 0);
-    registry.emplace<boxed_int>(entities[1], 1);
-    registry.emplace<boxed_int>(entities[2], 2);
-    registry.emplace<boxed_int>(entities[3], 3);
-    registry.emplace<boxed_int>(entities[4], 4);
+    registry.emplace<boxed_int>(entity[0], 0);
+    registry.emplace<boxed_int>(entity[1], 1);
+    registry.emplace<boxed_int>(entity[2], 2);
+    registry.emplace<boxed_int>(entity[3], 3);
+    registry.emplace<boxed_int>(entity[4], 4);
 
-    registry.emplace<char>(entities[2]);
+    registry.emplace<char>(entity[2]);
 
     group.sort([](const entt::entity lhs, const entt::entity rhs) {
         return lhs < rhs;
     });
 
-    ASSERT_EQ(group.handle().data()[0u], entities[4]);
-    ASSERT_EQ(group.handle().data()[1u], entities[3]);
-    ASSERT_EQ(group.handle().data()[2u], entities[1]);
-    ASSERT_EQ(group.handle().data()[3u], entities[0]);
+    ASSERT_EQ(group.handle().data()[0u], entity[4]);
+    ASSERT_EQ(group.handle().data()[1u], entity[3]);
+    ASSERT_EQ(group.handle().data()[2u], entity[1]);
+    ASSERT_EQ(group.handle().data()[3u], entity[0]);
 
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][0u].value, 4);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][1u].value, 3);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][2u].value, 1);
     ASSERT_EQ(group.storage<boxed_int>()->raw()[0u][3u].value, 0);
 
-    ASSERT_EQ(group.get<boxed_int>(entities[0]).value, 0);
-    ASSERT_EQ(group.get<0>(entities[1]).value, 1);
-    ASSERT_EQ(group.get<boxed_int>(entities[3]).value, 3);
-    ASSERT_EQ(group.get<0>(entities[4]).value, 4);
+    ASSERT_EQ(group.get<boxed_int>(entity[0]).value, 0);
+    ASSERT_EQ(group.get<0>(entity[1]).value, 1);
+    ASSERT_EQ(group.get<boxed_int>(entity[3]).value, 3);
+    ASSERT_EQ(group.get<0>(entity[4]).value, 4);
 
-    ASSERT_FALSE(group.contains(entities[2]));
+    ASSERT_FALSE(group.contains(entity[2]));
 }
 
 TEST(OwningGroup, IndexRebuiltOnDestroy) {

test/entt/entity/sigh_mixin.cpp

@@ -43,7 +43,7 @@ struct entt::basic_storage<empty_each_tag, entt::entity, std::allocator<empty_ea
 };
 
 TEST(SighMixin, GenericType) {
-    entt::entity entities[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
     entt::sigh_mixin<entt::storage<int>> pool;
     entt::sparse_set &base = pool;
     entt::registry registry;
@@ -55,8 +55,8 @@ TEST(SighMixin, GenericType) {
 
     ASSERT_TRUE(pool.empty());
 
-    pool.insert(entities, entities + 1u);
-    pool.erase(entities[0u]);
+    pool.insert(entity, entity + 1u);
+    pool.erase(entity[0u]);
 
     ASSERT_TRUE(pool.empty());
 
@@ -66,52 +66,52 @@ TEST(SighMixin, GenericType) {
     pool.on_construct().connect<&listener<entt::registry>>(on_construct);
     pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
 
-    ASSERT_NE(base.push(entities[0u]), base.end());
+    ASSERT_NE(base.push(entity[0u]), base.end());
 
-    pool.emplace(entities[1u]);
+    pool.emplace(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 0);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_EQ(pool.get(entities[0u]), 0);
-    ASSERT_EQ(pool.get(entities[1u]), 0);
+    ASSERT_EQ(pool.get(entity[0u]), 0);
+    ASSERT_EQ(pool.get(entity[1u]), 0);
 
-    base.erase(entities[0u]);
-    pool.erase(entities[1u]);
+    base.erase(entity[0u]);
+    pool.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 2);
     ASSERT_TRUE(pool.empty());
 
-    ASSERT_NE(base.push(std::begin(entities), std::end(entities)), base.end());
+    ASSERT_NE(base.push(std::begin(entity), std::end(entity)), base.end());
 
-    ASSERT_EQ(pool.get(entities[0u]), 0);
-    ASSERT_EQ(pool.get(entities[1u]), 0);
+    ASSERT_EQ(pool.get(entity[0u]), 0);
+    ASSERT_EQ(pool.get(entity[1u]), 0);
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[1u]);
+    base.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 3);
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[0u]);
+    base.erase(entity[0u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_TRUE(pool.empty());
 
-    pool.insert(std::begin(entities), std::end(entities), 3);
+    pool.insert(std::begin(entity), std::end(entity), 3);
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_EQ(pool.get(entities[0u]), 3);
-    ASSERT_EQ(pool.get(entities[1u]), 3);
+    ASSERT_EQ(pool.get(entity[0u]), 3);
+    ASSERT_EQ(pool.get(entity[1u]), 3);
 
-    pool.erase(std::begin(entities), std::end(entities));
+    pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 6);
@@ -119,7 +119,7 @@ TEST(SighMixin, GenericType) {
 }
 
 TEST(SighMixin, StableType) {
-    entt::entity entities[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
     entt::sigh_mixin<entt::storage<stable_type>> pool;
     entt::sparse_set &base = pool;
     entt::registry registry;
@@ -131,52 +131,52 @@ TEST(SighMixin, StableType) {
     pool.on_construct().connect<&listener<entt::registry>>(on_construct);
     pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
 
-    ASSERT_NE(base.push(entities[0u]), base.end());
+    ASSERT_NE(base.push(entity[0u]), base.end());
 
-    pool.emplace(entities[1u]);
+    pool.emplace(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 0);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_EQ(pool.get(entities[0u]).value, 0);
-    ASSERT_EQ(pool.get(entities[1u]).value, 0);
+    ASSERT_EQ(pool.get(entity[0u]).value, 0);
+    ASSERT_EQ(pool.get(entity[1u]).value, 0);
 
-    base.erase(entities[0u]);
-    pool.erase(entities[1u]);
+    base.erase(entity[0u]);
+    pool.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 2);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_NE(base.push(std::begin(entities), std::end(entities)), base.end());
+    ASSERT_NE(base.push(std::begin(entity), std::end(entity)), base.end());
 
-    ASSERT_EQ(pool.get(entities[0u]).value, 0);
-    ASSERT_EQ(pool.get(entities[1u]).value, 0);
+    ASSERT_EQ(pool.get(entity[0u]).value, 0);
+    ASSERT_EQ(pool.get(entity[1u]).value, 0);
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[1u]);
+    base.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 3);
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[0u]);
+    base.erase(entity[0u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_FALSE(pool.empty());
 
-    pool.insert(std::begin(entities), std::end(entities), stable_type{3});
+    pool.insert(std::begin(entity), std::end(entity), stable_type{3});
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_EQ(pool.get(entities[0u]).value, 3);
-    ASSERT_EQ(pool.get(entities[1u]).value, 3);
+    ASSERT_EQ(pool.get(entity[0u]).value, 3);
+    ASSERT_EQ(pool.get(entity[1u]).value, 3);
 
-    pool.erase(std::begin(entities), std::end(entities));
+    pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 6);
@@ -184,7 +184,7 @@ TEST(SighMixin, StableType) {
 }
 
 TEST(SighMixin, EmptyType) {
-    entt::entity entities[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
     entt::sigh_mixin<entt::storage<empty_type>> pool;
     entt::sparse_set &base = pool;
     entt::registry registry;
@@ -196,52 +196,52 @@ TEST(SighMixin, EmptyType) {
     pool.on_construct().connect<&listener<entt::registry>>(on_construct);
     pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
 
-    ASSERT_NE(base.push(entities[0u]), base.end());
+    ASSERT_NE(base.push(entity[0u]), base.end());
 
-    pool.emplace(entities[1u]);
+    pool.emplace(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 0);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_TRUE(pool.contains(entities[0u]));
-    ASSERT_TRUE(pool.contains(entities[1u]));
+    ASSERT_TRUE(pool.contains(entity[0u]));
+    ASSERT_TRUE(pool.contains(entity[1u]));
 
-    base.erase(entities[0u]);
-    pool.erase(entities[1u]);
+    base.erase(entity[0u]);
+    pool.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 2);
     ASSERT_EQ(on_destroy.value, 2);
     ASSERT_TRUE(pool.empty());
 
-    ASSERT_NE(base.push(std::begin(entities), std::end(entities)), base.end());
+    ASSERT_NE(base.push(std::begin(entity), std::end(entity)), base.end());
 
-    ASSERT_TRUE(pool.contains(entities[0u]));
-    ASSERT_TRUE(pool.contains(entities[1u]));
+    ASSERT_TRUE(pool.contains(entity[0u]));
+    ASSERT_TRUE(pool.contains(entity[1u]));
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[1u]);
+    base.erase(entity[1u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 3);
     ASSERT_FALSE(pool.empty());
 
-    base.erase(entities[0u]);
+    base.erase(entity[0u]);
 
     ASSERT_EQ(on_construct.value, 4);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_TRUE(pool.empty());
 
-    pool.insert(std::begin(entities), std::end(entities));
+    pool.insert(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_TRUE(pool.contains(entities[0u]));
-    ASSERT_TRUE(pool.contains(entities[1u]));
+    ASSERT_TRUE(pool.contains(entity[0u]));
+    ASSERT_TRUE(pool.contains(entity[1u]));
 
-    pool.erase(std::begin(entities), std::end(entities));
+    pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 6);
@@ -249,7 +249,7 @@ TEST(SighMixin, EmptyType) {
 }
 
 TEST(SighMixin, NonDefaultConstructibleType) {
-    entt::entity entities[2u]{entt::entity{3}, entt::entity{42}};
+    entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
     entt::sigh_mixin<entt::storage<non_default_constructible>> pool;
     entt::sparse_set &base = pool;
     entt::registry registry;
@@ -261,42 +261,42 @@ TEST(SighMixin, NonDefaultConstructibleType) {
     pool.on_construct().connect<&listener<entt::registry>>(on_construct);
     pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
 
-    ASSERT_EQ(base.push(entities[0u]), base.end());
+    ASSERT_EQ(base.push(entity[0u]), base.end());
 
-    pool.emplace(entities[1u], 3);
+    pool.emplace(entity[1u], 3);
 
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_EQ(on_construct.value, 1);
     ASSERT_EQ(on_destroy.value, 0);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_FALSE(pool.contains(entities[0u]));
-    ASSERT_EQ(pool.get(entities[1u]).value, 3);
+    ASSERT_FALSE(pool.contains(entity[0u]));
+    ASSERT_EQ(pool.get(entity[1u]).value, 3);
 
-    base.erase(entities[1u]);
+    base.erase(entity[1u]);
 
     ASSERT_EQ(pool.size(), 0u);
     ASSERT_EQ(on_construct.value, 1);
     ASSERT_EQ(on_destroy.value, 1);
     ASSERT_TRUE(pool.empty());
 
-    ASSERT_EQ(base.push(std::begin(entities), std::end(entities)), base.end());
+    ASSERT_EQ(base.push(std::begin(entity), std::end(entity)), base.end());
 
-    ASSERT_FALSE(pool.contains(entities[0u]));
-    ASSERT_FALSE(pool.contains(entities[1u]));
+    ASSERT_FALSE(pool.contains(entity[0u]));
+    ASSERT_FALSE(pool.contains(entity[1u]));
     ASSERT_TRUE(pool.empty());
 
-    pool.insert(std::begin(entities), std::end(entities), 3);
+    pool.insert(std::begin(entity), std::end(entity), 3);
 
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_EQ(on_construct.value, 3);
     ASSERT_EQ(on_destroy.value, 1);
     ASSERT_FALSE(pool.empty());
 
-    ASSERT_EQ(pool.get(entities[0u]).value, 3);
-    ASSERT_EQ(pool.get(entities[1u]).value, 3);
+    ASSERT_EQ(pool.get(entity[0u]).value, 3);
+    ASSERT_EQ(pool.get(entity[1u]).value, 3);
 
-    pool.erase(std::begin(entities), std::end(entities));
+    pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(pool.size(), 0u);
     ASSERT_EQ(on_construct.value, 3);
@@ -513,8 +513,8 @@ TEST(SighMixin, StorageEntity) {
     pool.emplace();
     pool.emplace(entt::entity{0});
 
-    entt::entity entities[1u]{};
-    pool.insert(entities, entities + 1u);
+    entt::entity entity[1u]{};
+    pool.insert(entity, entity + 1u);
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 3);
@@ -639,10 +639,10 @@ TEST(SighMixin, ThrowingAllocator) {
         ASSERT_TRUE(pool.empty());
 
         pool.emplace(entt::entity{0}, 0);
-        const entt::entity entities[2u]{entt::entity{1}, entt::entity{sparse_page_size}};
+        const entt::entity entity[2u]{entt::entity{1}, entt::entity{sparse_page_size}};
         test::throwing_allocator<entt::entity>::trigger_after_allocate = true;
 
-        ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), value_type{0}), test::throwing_allocator<entt::entity>::exception_type);
+        ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), value_type{0}), test::throwing_allocator<entt::entity>::exception_type);
         ASSERT_TRUE(pool.contains(entt::entity{1}));
         ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
@@ -651,7 +651,7 @@ TEST(SighMixin, ThrowingAllocator) {
         test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
         pool.compact();
 
-        ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), std::begin(components)), test::throwing_allocator<entt::entity>::exception_type);
+        ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), std::begin(components)), test::throwing_allocator<entt::entity>::exception_type);
         ASSERT_TRUE(pool.contains(entt::entity{1}));
         ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
@@ -681,21 +681,21 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_THROW(pool.emplace(entt::entity{0}, test::throwing_type{42}), typename test::throwing_type::exception_type);
     ASSERT_TRUE(pool.empty());
 
-    const entt::entity entities[2u]{entt::entity{42}, entt::entity{1}};
+    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}};
     const test::throwing_type components[2u]{42, 1};
 
     // basic exception safety
-    ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), test::throwing_type{42}), typename test::throwing_type::exception_type);
+    ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), test::throwing_type{42}), typename test::throwing_type::exception_type);
     ASSERT_EQ(pool.size(), 0u);
     ASSERT_FALSE(pool.contains(entt::entity{1}));
 
     // basic exception safety
-    ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), std::begin(components)), typename test::throwing_type::exception_type);
+    ASSERT_THROW(pool.insert(std::begin(entity), std::end(entity), std::begin(components)), typename test::throwing_type::exception_type);
     ASSERT_EQ(pool.size(), 0u);
     ASSERT_FALSE(pool.contains(entt::entity{1}));
 
     // basic exception safety
-    ASSERT_THROW(pool.insert(std::rbegin(entities), std::rend(entities), std::rbegin(components)), typename test::throwing_type::exception_type);
+    ASSERT_THROW(pool.insert(std::rbegin(entity), std::rend(entity), std::rbegin(components)), typename test::throwing_type::exception_type);
     ASSERT_EQ(pool.size(), 1u);
     ASSERT_TRUE(pool.contains(entt::entity{1}));
     ASSERT_EQ(pool.get(entt::entity{1}), 1);

test/entt/entity/snapshot.cpp

@@ -59,10 +59,10 @@ 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.in_use());
 
-    entt::entity entities[3u];
+    entt::entity entity[3u];
 
-    registry.create(std::begin(entities), std::end(entities));
-    registry.destroy(entities[1u]);
+    registry.create(std::begin(entity), std::end(entity));
+    registry.destroy(entity[1u]);
 
     data.clear();
     snapshot.get<entt::entity>(archive, "ignored"_hs);
@@ -93,12 +93,12 @@ TEST(BasicSnapshot, GetType) {
     entt::basic_snapshot snapshot{registry};
     const auto &storage = registry.storage<int>();
 
-    entt::entity entities[3u];
+    entt::entity entity[3u];
     const int values[3u]{1, 2, 3};
 
-    registry.create(std::begin(entities), std::end(entities));
-    registry.insert<int>(std::begin(entities), std::end(entities), std::begin(values));
-    registry.destroy(entities[1u]);
+    registry.create(std::begin(entity), std::end(entity));
+    registry.insert<int>(std::begin(entity), std::end(entity), std::begin(values));
+    registry.destroy(entity[1u]);
 
     std::vector<entt::any> data{};
     auto archive = [&data](auto &&elem) { data.emplace_back(std::forward<decltype(elem)>(elem)); };
@@ -119,13 +119,13 @@ TEST(BasicSnapshot, GetType) {
     ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entities[0u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
 
     ASSERT_NE(entt::any_cast<int>(&data[2u]), nullptr);
     ASSERT_EQ(entt::any_cast<int>(data[2u]), values[0u]);
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[3u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[3u]), entities[2u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[3u]), entity[2u]);
 
     ASSERT_NE(entt::any_cast<int>(&data[4u]), nullptr);
     ASSERT_EQ(entt::any_cast<int>(data[4u]), values[2u]);
@@ -139,11 +139,11 @@ TEST(BasicSnapshot, GetEmptyType) {
     entt::basic_snapshot snapshot{registry};
     const auto &storage = registry.storage<empty>();
 
-    entt::entity entities[3u];
+    entt::entity entity[3u];
 
-    registry.create(std::begin(entities), std::end(entities));
-    registry.insert<empty>(std::begin(entities), std::end(entities));
-    registry.destroy(entities[1u]);
+    registry.create(std::begin(entity), std::end(entity));
+    registry.insert<empty>(std::begin(entity), std::end(entity));
+    registry.destroy(entity[1u]);
 
     std::vector<entt::any> data{};
     auto archive = [&data](auto &&elem) { data.emplace_back(std::forward<decltype(elem)>(elem)); };
@@ -164,10 +164,10 @@ TEST(BasicSnapshot, GetEmptyType) {
     ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entities[0u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[2u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[2u]), entities[2u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[2u]), entity[2u]);
 }
 
 TEST(BasicSnapshot, GetTypeSparse) {
@@ -177,17 +177,17 @@ TEST(BasicSnapshot, GetTypeSparse) {
     entt::registry registry;
     entt::basic_snapshot snapshot{registry};
 
-    entt::entity entities[3u];
+    entt::entity entity[3u];
     const int values[3u]{1, 2, 3};
 
-    registry.create(std::begin(entities), std::end(entities));
-    registry.insert<int>(std::begin(entities), std::end(entities), std::begin(values));
-    registry.destroy(entities[1u]);
+    registry.create(std::begin(entity), std::end(entity));
+    registry.insert<int>(std::begin(entity), std::end(entity), std::begin(values));
+    registry.destroy(entity[1u]);
 
     std::vector<entt::any> data{};
     auto archive = [&data](auto &&elem) { data.emplace_back(std::forward<decltype(elem)>(elem)); };
 
-    snapshot.get<int>(archive, std::begin(entities), std::end(entities), "other"_hs);
+    snapshot.get<int>(archive, std::begin(entity), std::end(entity), "other"_hs);
 
     ASSERT_EQ(data.size(), 1u);
 
@@ -195,15 +195,15 @@ TEST(BasicSnapshot, GetTypeSparse) {
     ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), 0u);
 
     data.clear();
-    snapshot.get<int>(archive, std::begin(entities), std::end(entities));
+    snapshot.get<int>(archive, std::begin(entity), std::end(entity));
 
     ASSERT_EQ(data.size(), 6u);
 
     ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(&data[0u]), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), static_cast<typename traits_type::entity_type>(std::distance(std::begin(entities), std::end(entities))));
+    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), static_cast<typename traits_type::entity_type>(std::distance(std::begin(entity), std::end(entity))));
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entities[0u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
 
     ASSERT_NE(entt::any_cast<int>(&data[2u]), nullptr);
     ASSERT_EQ(entt::any_cast<int>(data[2u]), values[0u]);
@@ -212,7 +212,7 @@ TEST(BasicSnapshot, GetTypeSparse) {
     ASSERT_EQ(entt::any_cast<entt::entity>(data[3u]), static_cast<entt::entity>(entt::null));
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[4u]), nullptr);
-    ASSERT_EQ(entt::any_cast<entt::entity>(data[4u]), entities[2u]);
+    ASSERT_EQ(entt::any_cast<entt::entity>(data[4u]), entity[2u]);
 
     ASSERT_NE(entt::any_cast<int>(&data[5u]), nullptr);
     ASSERT_EQ(entt::any_cast<int>(data[5u]), values[2u]);
@@ -249,20 +249,20 @@ 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 entities[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)};
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
-    ASSERT_FALSE(registry.valid(entities[2u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
+    ASSERT_FALSE(registry.valid(entity[2u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
 
     loader.get<entt::entity>(archive);
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
-    ASSERT_FALSE(registry.valid(entities[2u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
+    ASSERT_FALSE(registry.valid(entity[2u]));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(storage.in_use(), 0u);
@@ -270,24 +270,24 @@ TEST(BasicSnapshotLoader, GetEntityType) {
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
-    data.emplace_back(entities[2u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
+    data.emplace_back(entity[2u]);
 
     loader.get<entt::entity>(archive, "ignored"_hs);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_TRUE(registry.valid(entities[1u]));
-    ASSERT_FALSE(registry.valid(entities[2u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_TRUE(registry.valid(entity[1u]));
+    ASSERT_FALSE(registry.valid(entity[2u]));
 
     ASSERT_EQ(storage.size(), 3u);
     ASSERT_EQ(storage.in_use(), 2u);
 
-    ASSERT_EQ(storage[0u], entities[0u]);
-    ASSERT_EQ(storage[1u], entities[1u]);
-    ASSERT_EQ(storage[2u], entities[2u]);
+    ASSERT_EQ(storage[0u], entity[0u]);
+    ASSERT_EQ(storage[1u], entity[1u]);
+    ASSERT_EQ(storage[2u], entity[2u]);
 
-    ASSERT_EQ(registry.create(), entities[2u]);
+    ASSERT_EQ(registry.create(), entity[2u]);
 }
 
 TEST(BasicSnapshotLoader, GetType) {
@@ -300,42 +300,42 @@ 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 entities[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)};
     const int values[2u]{1, 3};
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     loader.get<int>(archive, "other"_hs);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
     data.emplace_back(values[1u]);
 
     loader.get<int>(archive);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_TRUE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_TRUE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(entities[0u]));
-    ASSERT_TRUE(storage.contains(entities[1u]));
-    ASSERT_EQ(storage.get(entities[0u]), values[0u]);
-    ASSERT_EQ(storage.get(entities[1u]), values[1u]);
+    ASSERT_TRUE(storage.contains(entity[0u]));
+    ASSERT_TRUE(storage.contains(entity[1u]));
+    ASSERT_EQ(storage.get(entity[0u]), values[0u]);
+    ASSERT_EQ(storage.get(entity[1u]), values[1u]);
 }
 
 TEST(BasicSnapshotLoader, GetEmptyType) {
@@ -348,35 +348,35 @@ 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 entities[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)};
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
 
     loader.get<empty>(archive, "other"_hs);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<empty>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
 
     loader.get<empty>(archive);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_TRUE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_TRUE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(entities[0u]));
-    ASSERT_TRUE(storage.contains(entities[1u]));
+    ASSERT_TRUE(storage.contains(entity[0u]));
+    ASSERT_TRUE(storage.contains(entity[1u]));
 }
 
 TEST(BasicSnapshotLoader, GetTypeSparse) {
@@ -389,45 +389,45 @@ 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 entities[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)};
     const int values[2u]{1, 3};
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
     data.emplace_back(static_cast<entt::entity>(entt::null));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     loader.get<int>(archive, "other"_hs);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
 
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     data.emplace_back(static_cast<entt::entity>(entt::null));
 
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
     data.emplace_back(values[1u]);
 
     loader.get<int>(archive);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_TRUE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_TRUE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(entities[0u]));
-    ASSERT_TRUE(storage.contains(entities[1u]));
-    ASSERT_EQ(storage.get(entities[0u]), values[0u]);
-    ASSERT_EQ(storage.get(entities[1u]), values[1u]);
+    ASSERT_TRUE(storage.contains(entity[0u]));
+    ASSERT_TRUE(storage.contains(entity[1u]));
+    ASSERT_EQ(storage.get(entity[0u]), values[0u]);
+    ASSERT_EQ(storage.get(entity[1u]), values[1u]);
 }
 
 TEST(BasicSnapshotLoader, GetTypeWithListener) {
@@ -466,32 +466,32 @@ 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 entities[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)};
     const int value = 42;
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(value);
 
     loader.get<entt::entity>(archive);
     loader.get<int>(archive);
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_TRUE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_TRUE(registry.valid(entity[1u]));
 
     loader.orphans();
 
-    ASSERT_TRUE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 }
 
 TEST(BasicContinuousLoader, Constructors) {
@@ -518,28 +518,28 @@ 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 entities[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)};
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
-    ASSERT_FALSE(registry.valid(entities[2u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
+    ASSERT_FALSE(registry.valid(entity[2u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
 
     loader.get<entt::entity>(archive);
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
-    ASSERT_FALSE(registry.valid(entities[2u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
+    ASSERT_FALSE(registry.valid(entity[2u]));
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
-    ASSERT_FALSE(loader.contains(entities[2u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
+    ASSERT_FALSE(loader.contains(entity[2u]));
 
-    ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[2u]), static_cast<entt::entity>(entt::null));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(storage.in_use(), 0u);
@@ -547,100 +547,100 @@ TEST(BasicContinuousLoader, GetEntityType) {
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
-    data.emplace_back(entities[2u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
+    data.emplace_back(entity[2u]);
 
     loader.get<entt::entity>(archive, "ignored"_hs);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
-    ASSERT_FALSE(loader.contains(entities[2u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
+    ASSERT_FALSE(loader.contains(entity[2u]));
 
-    ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
-    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[2u]), static_cast<entt::entity>(entt::null));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 2u);
     ASSERT_EQ(storage.in_use(), 2u);
 
-    ASSERT_EQ(storage[0u], loader.map(entities[0u]));
-    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
+    ASSERT_EQ(storage[0u], loader.map(entity[0u]));
+    ASSERT_EQ(storage[1u], loader.map(entity[1u]));
 
-    ASSERT_EQ(registry.create(), entities[2u]);
+    ASSERT_EQ(registry.create(), entity[2u]);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
-    data.emplace_back(entities[2u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
+    data.emplace_back(entity[2u]);
 
     loader.get<entt::entity>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
-    ASSERT_TRUE(loader.contains(entities[2u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
+    ASSERT_TRUE(loader.contains(entity[2u]));
 
-    ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
-    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_NE(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[2u]), static_cast<entt::entity>(entt::null));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[2u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[2u])));
 
     ASSERT_EQ(storage.size(), 4u);
     ASSERT_EQ(storage.in_use(), 4u);
 
-    ASSERT_EQ(storage[0u], loader.map(entities[0u]));
-    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
-    ASSERT_EQ(storage[3u], loader.map(entities[2u]));
+    ASSERT_EQ(storage[0u], loader.map(entity[0u]));
+    ASSERT_EQ(storage[1u], loader.map(entity[1u]));
+    ASSERT_EQ(storage[3u], loader.map(entity[2u]));
 
-    registry.destroy(loader.map(entities[1u]));
+    registry.destroy(loader.map(entity[1u]));
 
-    ASSERT_TRUE(loader.contains(entities[1u]));
-    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(loader.contains(entity[1u]));
+    ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
 
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
 
     loader.get<entt::entity>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[1u]));
-    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
-    ASSERT_EQ(storage[3u], loader.map(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
+    ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
+    ASSERT_EQ(storage[3u], loader.map(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
 
-    data.emplace_back(entities[1u]);
-    data.emplace_back(entities[2u]);
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[1u]);
+    data.emplace_back(entity[2u]);
+    data.emplace_back(entity[0u]);
 
     loader.get<entt::entity>(archive, "ignored"_hs);
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
-    ASSERT_FALSE(loader.contains(entities[2u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
+    ASSERT_FALSE(loader.contains(entity[2u]));
 
-    ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
-    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entity[2u]), static_cast<entt::entity>(entt::null));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 4u);
     ASSERT_EQ(storage.in_use(), 2u);
 
-    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
+    ASSERT_EQ(storage[1u], loader.map(entity[1u]));
 }
 
 TEST(BasicContinuousLoader, GetType) {
@@ -653,51 +653,51 @@ 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 entities[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)};
     const int values[2u]{1, 3};
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     loader.get<int>(archive, "other"_hs);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
     data.emplace_back(values[1u]);
 
     loader.get<int>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
-    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
-    ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
-    ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
+    ASSERT_TRUE(storage.contains(loader.map(entity[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entity[1u])));
+    ASSERT_EQ(storage.get(loader.map(entity[0u])), values[0u]);
+    ASSERT_EQ(storage.get(loader.map(entity[1u])), values[1u]);
 }
 
 TEST(BasicContinuousLoader, GetTypeExtended) {
@@ -709,8 +709,8 @@ TEST(BasicContinuousLoader, GetTypeExtended) {
     const auto &storage = registry.storage<shadow>();
 
     std::vector<entt::any> data{};
-    const entt::entity entities[2u]{traits_type::construct(0u, 1u), traits_type::construct(1u, 1u)};
-    const shadow value{entities[0u]};
+    const entt::entity entity[2u]{traits_type::construct(0u, 1u), traits_type::construct(1u, 1u)};
+    const shadow value{entity[0u]};
 
     auto archive = [&loader, &data, pos = 0u](auto &elem) mutable {
         elem = entt::any_cast<std::remove_reference_t<decltype(elem)>>(data[pos++]);
@@ -720,37 +720,37 @@ TEST(BasicContinuousLoader, GetTypeExtended) {
         }
     };
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
     data.emplace_back(value);
 
     loader.get<entt::entity>(archive);
     loader.get<shadow>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     ASSERT_EQ(storage.size(), 1u);
-    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
-    ASSERT_EQ(storage.get(loader.map(entities[1u])).target, loader.map(entities[0u]));
+    ASSERT_TRUE(storage.contains(loader.map(entity[1u])));
+    ASSERT_EQ(storage.get(loader.map(entity[1u])).target, loader.map(entity[0u]));
 }
 
 TEST(BasicContinuousLoader, GetEmptyType) {
@@ -763,44 +763,44 @@ 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 entities[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)};
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
 
     loader.get<empty>(archive, "other"_hs);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<empty>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
 
     loader.get<empty>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
-    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
+    ASSERT_TRUE(storage.contains(loader.map(entity[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entity[1u])));
 }
 
 TEST(BasicContinuousLoader, GetTypeSparse) {
@@ -813,54 +813,54 @@ 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 entities[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)};
     const int values[2u]{1, 3};
 
-    ASSERT_FALSE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
     data.emplace_back(static_cast<entt::entity>(entt::null));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     loader.get<int>(archive, "other"_hs);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_FALSE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
 
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(values[0u]);
 
     data.emplace_back(static_cast<entt::entity>(entt::null));
 
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[1u]);
     data.emplace_back(values[1u]);
 
     loader.get<int>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     ASSERT_EQ(storage.size(), 2u);
-    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
-    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
-    ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
-    ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
+    ASSERT_TRUE(storage.contains(loader.map(entity[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entity[1u])));
+    ASSERT_EQ(storage.get(loader.map(entity[0u])), values[0u]);
+    ASSERT_EQ(storage.get(loader.map(entity[1u])), values[1u]);
 }
 
 TEST(BasicContinuousLoader, GetTypeWithListener) {
@@ -899,36 +899,36 @@ 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 entities[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)};
     const int value = 42;
 
-    ASSERT_FALSE(registry.valid(entities[0u]));
-    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entity[0u]));
+    ASSERT_FALSE(registry.valid(entity[1u]));
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
     data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
 
-    data.emplace_back(entities[0u]);
-    data.emplace_back(entities[1u]);
+    data.emplace_back(entity[0u]);
+    data.emplace_back(entity[1u]);
 
     data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(entities[0u]);
+    data.emplace_back(entity[0u]);
     data.emplace_back(value);
 
     loader.get<entt::entity>(archive);
     loader.get<int>(archive);
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
 
     loader.orphans();
 
-    ASSERT_TRUE(loader.contains(entities[0u]));
-    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entity[0u]));
+    ASSERT_TRUE(loader.contains(entity[1u]));
 
-    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
-    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entity[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 }

test/entt/entity/storage_entity.cpp

@@ -13,15 +13,15 @@ TEST(StorageEntity, TypeAndPolicy) {
 }
 
 TEST(StorageEntity, Functionalities) {
-    entt::entity entities[2u]{entt::entity{0}, entt::entity{1}};
+    entt::entity entity[2u]{entt::entity{0}, entt::entity{1}};
     entt::storage<entt::entity> pool;
 
     ASSERT_TRUE(pool.empty());
     ASSERT_EQ(pool.size(), 0u);
     ASSERT_EQ(pool.in_use(), 0u);
 
-    ASSERT_EQ(*pool.push(entt::null), entities[0u]);
-    ASSERT_EQ(*pool.push(entt::tombstone), entities[1u]);
+    ASSERT_EQ(*pool.push(entt::null), entity[0u]);
+    ASSERT_EQ(*pool.push(entt::tombstone), entity[1u]);
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
@@ -33,10 +33,10 @@ TEST(StorageEntity, Functionalities) {
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_EQ(pool.in_use(), 1u);
 
-    ASSERT_NO_THROW(pool.get(entities[0u]));
-    ASSERT_EQ(pool.get_as_tuple(entities[0u]), std::tuple<>{});
+    ASSERT_NO_THROW(pool.get(entity[0u]));
+    ASSERT_EQ(pool.get_as_tuple(entity[0u]), std::tuple<>{});
 
-    pool.erase(entities[0u]);
+    pool.erase(entity[0u]);
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
@@ -165,13 +165,13 @@ TEST(StorageEntity, Push) {
     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 entities[2u]{entt::entity{1}, traits_type::construct(5, 3)};
+    entt::entity entity[2u]{entt::entity{1}, traits_type::construct(5, 3)};
 
-    pool.erase(entities, entities + 2u);
+    pool.erase(entity, entity + 2u);
     pool.erase(entt::entity{2});
 
-    ASSERT_EQ(pool.current(entities[0u]), 1);
-    ASSERT_EQ(pool.current(entities[1u]), 4);
+    ASSERT_EQ(pool.current(entity[0u]), 1);
+    ASSERT_EQ(pool.current(entity[1u]), 4);
     ASSERT_EQ(pool.current(entt::entity{2}), 1);
 
     ASSERT_LT(pool.index(entt::entity{0}), pool.in_use());
@@ -191,7 +191,7 @@ TEST(StorageEntity, Emplace) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::storage<entt::entity> pool;
-    entt::entity entities[2u]{};
+    entt::entity entity[2u]{};
 
     ASSERT_EQ(pool.emplace(), entt::entity{0});
     ASSERT_EQ(pool.emplace(entt::null), entt::entity{1});
@@ -216,10 +216,10 @@ TEST(StorageEntity, Emplace) {
     ASSERT_EQ(pool.emplace(), traits_type::construct(2, 1));
 
     pool.erase(traits_type::construct(2, 1));
-    pool.insert(entities, entities + 2u);
+    pool.insert(entity, entity + 2u);
 
-    ASSERT_EQ(entities[0u], traits_type::construct(2, 2));
-    ASSERT_EQ(entities[1u], entt::entity{8});
+    ASSERT_EQ(entity[0u], traits_type::construct(2, 2));
+    ASSERT_EQ(entity[1u], entt::entity{8});
 }
 
 TEST(StorageEntity, Patch) {
@@ -246,27 +246,27 @@ ENTT_DEBUG_TEST(StorageEntityDeathTest, Patch) {
 
 TEST(StorageEntity, Insert) {
     entt::storage<entt::entity> pool;
-    entt::entity entities[2u]{};
+    entt::entity entity[2u]{};
 
-    pool.insert(std::begin(entities), std::end(entities));
+    pool.insert(std::begin(entity), std::end(entity));
 
-    ASSERT_TRUE(pool.contains(entities[0u]));
-    ASSERT_TRUE(pool.contains(entities[1u]));
+    ASSERT_TRUE(pool.contains(entity[0u]));
+    ASSERT_TRUE(pool.contains(entity[1u]));
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_EQ(pool.in_use(), 2u);
 
-    pool.erase(std::begin(entities), std::end(entities));
+    pool.erase(std::begin(entity), std::end(entity));
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
     ASSERT_EQ(pool.in_use(), 0u);
 
-    pool.insert(entities, entities + 1u);
+    pool.insert(entity, entity + 1u);
 
-    ASSERT_TRUE(pool.contains(entities[0u]));
-    ASSERT_FALSE(pool.contains(entities[1u]));
+    ASSERT_TRUE(pool.contains(entity[0u]));
+    ASSERT_FALSE(pool.contains(entity[1u]));
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(pool.size(), 2u);
@@ -275,12 +275,12 @@ TEST(StorageEntity, Insert) {
 
 TEST(StorageEntity, Pack) {
     entt::storage<entt::entity> pool;
-    entt::entity entities[3u]{entt::entity{1}, entt::entity{3}, entt::entity{42}};
+    entt::entity entity[3u]{entt::entity{1}, entt::entity{3}, entt::entity{42}};
 
-    pool.push(entities, entities + 3u);
-    std::swap(entities[0u], entities[1u]);
+    pool.push(entity, entity + 3u);
+    std::swap(entity[0u], entity[1u]);
 
-    const auto len = pool.pack(entities + 1u, entities + 3u);
+    const auto len = pool.pack(entity + 1u, entity + 3u);
     auto it = pool.each().cbegin().base();
 
     ASSERT_NE(it, pool.cbegin());
@@ -290,11 +290,11 @@ TEST(StorageEntity, Pack) {
     ASSERT_NE(it + len, pool.cend());
     ASSERT_EQ(it + len + 1u, pool.cend());
 
-    ASSERT_EQ(*it++, entities[1u]);
-    ASSERT_EQ(*it++, entities[2u]);
+    ASSERT_EQ(*it++, entity[1u]);
+    ASSERT_EQ(*it++, entity[2u]);
 
     ASSERT_NE(it, pool.cend());
-    ASSERT_EQ(*it++, entities[0u]);
+    ASSERT_EQ(*it++, entity[0u]);
     ASSERT_EQ(it, pool.cend());
 }
 

test/snapshot/snapshot.cpp

@@ -112,12 +112,12 @@ TEST(Snapshot, Continuous) {
     entt::registry source;
     entt::registry destination;
 
-    std::vector<entt::entity> entities;
+    std::vector<entt::entity> entity;
     for(auto i = 0; i < 10; ++i) {
-        entities.push_back(source.create());
+        entity.push_back(source.create());
     }
 
-    for(auto entity: entities) {
+    for(auto entity: entity) {
         source.destroy(entity);
     }