From 31392ce1aab2793d6a6f1b7a78bf96a2c474f330 Mon Sep 17 00:00:00 2001
From: Christian Mazakas <christian.mazakas@gmail.com>
Date: Thu, 23 Dec 2021 13:02:18 -0800
Subject: [PATCH] Add transparent test support for set's `erase()`

---
 test/unordered/transparent_tests.cpp | 107 +++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/test/unordered/transparent_tests.cpp b/test/unordered/transparent_tests.cpp
index 19b4ef10..9734e28e 100644
--- a/test/unordered/transparent_tests.cpp
+++ b/test/unordered/transparent_tests.cpp
@@ -768,6 +768,109 @@ template <class UnorderedMap> void test_map_non_transparent_erase()
   BOOST_TEST_EQ(key::count_, key_count);
 }
 
+typedef boost::unordered_set<int, transparent_hasher, transparent_key_equal>
+  transparent_unordered_set;
+
+transparent_unordered_set::iterator set_erase_overload_compile_test()
+{
+  convertible_to_iterator<transparent_unordered_set> c;
+  transparent_unordered_set set;
+  transparent_unordered_set::iterator pos = set.begin();
+  pos = c;
+  return set.erase(c);
+}
+
+transparent_unordered_set::const_iterator
+set_erase_const_overload_compile_test()
+{
+  convertible_to_const_iterator<transparent_unordered_set> c;
+  transparent_unordered_set set;
+  transparent_unordered_set::const_iterator pos = set.begin();
+  pos = c;
+  return set.erase(c);
+}
+
+template <class UnorderedSet> void test_set_transparent_erase()
+{
+  count_reset();
+
+  UnorderedSet set;
+
+  unsigned long num_erased = 0;
+
+  num_erased = set.erase(0);
+  BOOST_TEST(set.empty());
+  BOOST_TEST_EQ(num_erased, 0);
+  BOOST_TEST_EQ(key::count_, 0);
+
+  set.insert(0);
+  set.insert(1);
+  set.insert(2);
+  set.insert(0);
+  set.insert(0);
+  set.insert(0);
+
+  BOOST_TEST(set.find(0) != set.end());
+
+  int const expected_key_count = key::count_;
+  int const expected_num_erased = static_cast<int>(set.size() - 2);
+
+  num_erased = set.erase(0);
+  BOOST_TEST_EQ(num_erased, expected_num_erased);
+  BOOST_TEST_EQ(set.size(), 2);
+  BOOST_TEST(set.find(0) == set.end());
+
+  num_erased = set.erase(1337);
+  BOOST_TEST_EQ(num_erased, 0);
+  BOOST_TEST_EQ(set.size(), 2);
+
+  BOOST_TEST_EQ(key::count_, expected_key_count);
+}
+
+template <class UnorderedSet> void test_set_non_transparent_erase()
+{
+  count_reset();
+
+  UnorderedSet set;
+
+  unsigned long num_erased = 0;
+
+  num_erased = set.erase(0);
+  BOOST_TEST(set.empty());
+  BOOST_TEST_EQ(num_erased, 0);
+  BOOST_TEST_EQ(key::count_, 1);
+
+  set.insert(0);
+  set.insert(1);
+  set.insert(2);
+  set.insert(0);
+  set.insert(0);
+  set.insert(0);
+
+  int const expected_num_erased = static_cast<int>(set.size() - 2);
+
+  BOOST_TEST(set.find(0) != set.end());
+
+  int key_count = key::count_;
+
+  num_erased = set.erase(0);
+  ++key_count;
+  BOOST_TEST_EQ(key::count_, key_count);
+  BOOST_TEST_EQ(num_erased, expected_num_erased);
+  BOOST_TEST_EQ(set.size(), 2);
+
+  BOOST_TEST(set.find(0) == set.end());
+  ++key_count;
+
+  BOOST_TEST_EQ(key::count_, key_count);
+
+  num_erased = set.erase(1337);
+  ++key_count;
+  BOOST_TEST_EQ(num_erased, 0);
+  BOOST_TEST_EQ(set.size(), 2);
+  BOOST_TEST_EQ(key::count_, key_count);
+}
+
 // test that in the presence of the member function template `extract()`, we
 // still invoke the correct iterator overloads when the type is implicitly
 // convertible
@@ -988,6 +1091,7 @@ void test_unordered_set()
       unordered_set;
 
     test_set_transparent_find<unordered_set>();
+    test_set_transparent_erase<unordered_set>();
   }
 
   {
@@ -996,6 +1100,7 @@ void test_unordered_set()
     typedef boost::unordered_set<key, hasher, key_equal> unordered_set;
 
     test_set_non_transparent_find<unordered_set>();
+    test_set_non_transparent_erase<unordered_set>();
   }
 
   {
@@ -1005,6 +1110,7 @@ void test_unordered_set()
       unordered_set;
 
     test_set_non_transparent_find<unordered_set>();
+    test_set_non_transparent_erase<unordered_set>();
   }
 
   {
@@ -1014,6 +1120,7 @@ void test_unordered_set()
       unordered_set;
 
     test_set_non_transparent_find<unordered_set>();
+    test_set_non_transparent_erase<unordered_set>();
   }
 }