test: avoid using scoped iterators (simple cases)

test/entt/entity/sparse_set.cpp

@@ -607,28 +607,28 @@ TYPED_TEST(SparseSet, ScopedIterator) {
         switch(policy) {
         case entt::deletion_policy::swap_and_pop:
         case entt::deletion_policy::in_place: {
-            ASSERT_EQ(set.begin(), set.begin(0));
-            ASSERT_EQ(set.end(), set.end(0));
-            ASSERT_NE(set.cbegin(0), set.cend(0));
+            ASSERT_EQ(set.begin(), set.begin());
+            ASSERT_EQ(set.end(), set.end());
+            ASSERT_NE(set.cbegin(), set.cend());
         } break;
         case entt::deletion_policy::swap_only: {
             ASSERT_NE(set.begin(), set.begin(0));
             ASSERT_EQ(set.begin() + 1, set.begin(0));
-            ASSERT_EQ(set.end(), set.end(0));
-            ASSERT_NE(set.cbegin(0), set.cend(0));
+            ASSERT_EQ(set.end(), set.end());
+            ASSERT_NE(set.cbegin(0), set.cend());
 
             set.free_list(0);
 
             ASSERT_NE(set.begin(), set.begin(0));
             ASSERT_EQ(set.begin() + 2, set.begin(0));
-            ASSERT_EQ(set.end(), set.end(0));
-            ASSERT_EQ(set.cbegin(0), set.cend(0));
+            ASSERT_EQ(set.end(), set.end());
+            ASSERT_EQ(set.cbegin(0), set.cend());
 
             set.free_list(2);
 
             ASSERT_EQ(set.begin(), set.begin(0));
-            ASSERT_EQ(set.end(), set.end(0));
-            ASSERT_NE(set.cbegin(0), set.cend(0));
+            ASSERT_EQ(set.end(), set.end());
+            ASSERT_NE(set.cbegin(0), set.cend());
         } break;
         }
     }
@@ -651,28 +651,28 @@ TYPED_TEST(SparseSet, ScopedReverseIterator) {
         switch(policy) {
         case entt::deletion_policy::swap_and_pop:
         case entt::deletion_policy::in_place: {
-            ASSERT_EQ(set.rbegin(), set.rbegin(0));
+            ASSERT_EQ(set.rbegin(), set.rbegin());
             ASSERT_EQ(set.rend(), set.rend(0));
-            ASSERT_NE(set.crbegin(0), set.crend(0));
+            ASSERT_NE(set.crbegin(), set.crend(0));
         } break;
         case entt::deletion_policy::swap_only: {
-            ASSERT_EQ(set.rbegin(), set.rbegin(0));
+            ASSERT_EQ(set.rbegin(), set.rbegin());
             ASSERT_NE(set.rend(), set.rend(0));
             ASSERT_EQ(set.rend() - 1, set.rend(0));
-            ASSERT_NE(set.crbegin(0), set.crend(0));
+            ASSERT_NE(set.crbegin(), set.crend(0));
 
             set.free_list(0);
 
-            ASSERT_EQ(set.rbegin(), set.rbegin(0));
+            ASSERT_EQ(set.rbegin(), set.rbegin());
             ASSERT_NE(set.rend(), set.rend(0));
             ASSERT_EQ(set.rend() - 2, set.rend(0));
-            ASSERT_EQ(set.crbegin(0), set.crend(0));
+            ASSERT_EQ(set.crbegin(), set.crend(0));
 
             set.free_list(2);
 
-            ASSERT_EQ(set.rbegin(), set.rbegin(0));
+            ASSERT_EQ(set.rbegin(), set.rbegin());
             ASSERT_EQ(set.rend(), set.rend(0));
-            ASSERT_NE(set.crbegin(0), set.crend(0));
+            ASSERT_NE(set.crbegin(), set.crend(0));
         } break;
         }
     }

test/entt/entity/storage_entity.cpp

@@ -334,21 +334,21 @@ TEST(StorageEntity, FreeList) {
 
     ASSERT_EQ(pool.free_list(), 1u);
     ASSERT_EQ(pool.begin(), pool.begin(0));
-    ASSERT_EQ(pool.end(), pool.end(0));
+    ASSERT_EQ(pool.end(), pool.end());
     ASSERT_EQ(pool.size(), 1u);
 
     pool.free_list(0u);
 
     ASSERT_EQ(pool.free_list(), 0u);
     ASSERT_NE(pool.begin(), pool.begin(0));
-    ASSERT_EQ(pool.end(), pool.end(0));
+    ASSERT_EQ(pool.end(), pool.end());
     ASSERT_EQ(pool.size(), 1u);
 
     pool.free_list(1u);
 
     ASSERT_EQ(pool.free_list(), 1u);
     ASSERT_EQ(pool.begin(), pool.begin(0));
-    ASSERT_EQ(pool.end(), pool.end(0));
+    ASSERT_EQ(pool.end(), pool.end());
     ASSERT_EQ(pool.size(), 1u);
 }
 
@@ -592,7 +592,7 @@ TEST(StorageEntity, SortOrdered) {
     pool.push(entity.begin(), entity.end());
     pool.sort(std::less{});
 
-    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), pool.begin(0), pool.end(0)));
+    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), pool.begin(0), pool.end()));
 }
 
 TEST(StorageEntity, SortReverse) {
@@ -603,7 +603,7 @@ TEST(StorageEntity, SortReverse) {
     pool.push(entity.begin(), entity.end());
     pool.sort(std::less{});
 
-    ASSERT_TRUE(std::equal(entity.begin(), entity.end(), pool.begin(0), pool.end(0)));
+    ASSERT_TRUE(std::equal(entity.begin(), entity.end(), pool.begin(0), pool.end()));
 }
 
 TEST(StorageEntity, SortUnordered) {
@@ -629,7 +629,7 @@ TEST(StorageEntity, SortN) {
     pool.push(entity.begin(), entity.end());
     pool.sort_n(0u, std::less{});
 
-    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), pool.begin(0), pool.end(0)));
+    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), pool.begin(0), pool.end()));
 
     pool.sort_n(2u, std::less{});
 
@@ -655,11 +655,11 @@ TEST(StorageEntity, SortAsDisjoint) {
 
     lhs.push(entity.begin(), entity.end());
 
-    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), lhs.begin(0), lhs.end(0)));
+    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), lhs.begin(0), lhs.end()));
 
-    lhs.sort_as(rhs.begin(0), rhs.end(0));
+    lhs.sort_as(rhs.begin(0), rhs.end());
 
-    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), lhs.begin(0), lhs.end(0)));
+    ASSERT_TRUE(std::equal(entity.rbegin(), entity.rend(), lhs.begin(0), lhs.end()));
 }
 
 TEST(StorageEntity, SortAsOverlap) {
@@ -672,10 +672,10 @@ TEST(StorageEntity, SortAsOverlap) {
     lhs.push(lhs_entity.begin(), lhs_entity.end());
     rhs.push(rhs_entity.begin(), rhs_entity.end());
 
-    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end(0)));
-    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end(0)));
+    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end()));
+    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end()));
 
-    lhs.sort_as(rhs.begin(0), rhs.end(0));
+    lhs.sort_as(rhs.begin(0), rhs.end());
 
     ASSERT_EQ(lhs.data()[0u], lhs_entity[0u]);
     ASSERT_EQ(lhs.data()[1u], lhs_entity[2u]);
@@ -692,12 +692,12 @@ TEST(StorageEntity, SortAsOrdered) {
     lhs.push(lhs_entity.begin(), lhs_entity.end());
     rhs.push(rhs_entity.begin(), rhs_entity.end());
 
-    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end(0)));
-    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end(0)));
+    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end()));
+    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end()));
 
-    rhs.sort_as(lhs.begin(0), lhs.end(0));
+    rhs.sort_as(lhs.begin(0), lhs.end());
 
-    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end(0)));
+    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end()));
 }
 
 TEST(StorageEntity, SortAsReverse) {
@@ -710,10 +710,10 @@ TEST(StorageEntity, SortAsReverse) {
     lhs.push(lhs_entity.begin(), lhs_entity.end());
     rhs.push(rhs_entity.begin(), rhs_entity.end());
 
-    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end(0)));
-    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end(0)));
+    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end()));
+    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end()));
 
-    rhs.sort_as(lhs.begin(0), lhs.end(0));
+    rhs.sort_as(lhs.begin(0), lhs.end());
 
     ASSERT_EQ(rhs.data()[0u], rhs_entity[5u]);
     ASSERT_EQ(rhs.data()[1u], rhs_entity[4u]);
@@ -733,10 +733,10 @@ TEST(StorageEntity, SortAsUnordered) {
     lhs.push(lhs_entity.begin(), lhs_entity.end());
     rhs.push(rhs_entity.begin(), rhs_entity.end());
 
-    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end(0)));
-    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end(0)));
+    ASSERT_TRUE(std::equal(lhs_entity.rbegin(), lhs_entity.rend(), lhs.begin(0), lhs.end()));
+    ASSERT_TRUE(std::equal(rhs_entity.rbegin(), rhs_entity.rend(), rhs.begin(0), rhs.end()));
 
-    rhs.sort_as(lhs.begin(0), lhs.end(0));
+    rhs.sort_as(lhs.begin(0), lhs.end());
 
     ASSERT_EQ(rhs.data()[0u], rhs_entity[2u]);
     ASSERT_EQ(rhs.data()[1u], rhs_entity[3u]);