test: code coverage for sparse set and storage range-erase

test/entt/entity/sparse_set.cpp

@@ -138,6 +138,39 @@ TEST(SparseSet, Insert) {
     ASSERT_EQ(set.data()[set.index(entt::entity{24})], entt::entity{24});
 }
 
+TEST(SparseSet, RangeErase) {
+    entt::sparse_set set;
+    entt::entity entities[3];
+
+    entities[0] = entt::entity{3};
+    entities[1] = entt::entity{42};
+    entities[2] = entt::entity{9};
+
+    set.insert(std::begin(entities), std::end(entities));
+    set.erase(set.begin(), set.end());
+
+    ASSERT_TRUE(set.empty());
+
+    set.insert(std::begin(entities), std::end(entities));
+    set.erase(set.rbegin(), set.rend());
+
+    ASSERT_TRUE(set.empty());
+
+    set.insert(std::begin(entities), std::end(entities));
+    set.erase(entities, entities + 2u);
+
+    ASSERT_FALSE(set.empty());
+    ASSERT_EQ(*set.begin(), entt::entity{9});
+
+    set.clear();
+    set.insert(std::begin(entities), std::end(entities));
+    std::swap(entities[1], entities[2]);
+    set.erase(entities, entities + 2u);
+
+    ASSERT_FALSE(set.empty());
+    ASSERT_EQ(*set.begin(), entt::entity{42});
+}
+
 TEST(SparseSet, Iterator) {
     using iterator = typename entt::sparse_set::iterator;
 

test/entt/entity/storage.cpp

@@ -120,6 +120,36 @@ TEST(Storage, InsertEmptyType) {
     ASSERT_EQ(pool.size(), 2u);
 }
 
+TEST(Storage, RangeErase) {
+    entt::storage<int> pool;
+    entt::sparse_set &base = pool;
+
+    pool.emplace(entt::entity{3});
+    pool.emplace(entt::entity{42});
+    base.erase(base.begin(), base.end());
+
+    ASSERT_TRUE(pool.empty());
+
+    pool.emplace(entt::entity{3}, 3);
+    pool.emplace(entt::entity{42}, 42);
+    pool.emplace(entt::entity{9}, 9);
+    base.erase(base.rbegin(), base.rbegin() + 2u);
+
+    ASSERT_FALSE(pool.empty());
+    ASSERT_EQ(*pool.begin(), 9);
+
+    pool.clear();
+    pool.emplace(entt::entity{3}, 3);
+    pool.emplace(entt::entity{42}, 42);
+    pool.emplace(entt::entity{9}, 9);
+
+    entt::entity entities[2]{entt::entity{3}, entt::entity{9}};
+    base.erase(std::begin(entities), std::end(entities));
+
+    ASSERT_FALSE(pool.empty());
+    ASSERT_EQ(*pool.begin(), 42);
+}
+
 TEST(Storage, AggregatesMustWork) {
     struct aggregate_type { int value; };
     // the goal of this test is to enforce the requirements for aggregate types