Add transparent test support for set's extract()

test/unordered/transparent_tests.cpp

@@ -1443,6 +1443,128 @@ template <class UnorderedMap> void test_map_non_transparent_extract()
   BOOST_TEST_EQ(key::count_, key_count);
 }
 
+transparent_unordered_set::node_type set_extract_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.extract(c);
+}
+
+transparent_unordered_set::node_type set_extract_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.extract(c);
+}
+
+template <class UnorderedSet> void test_set_transparent_extract()
+{
+  typedef typename UnorderedSet::node_type node_type;
+
+  count_reset();
+
+  UnorderedSet set;
+
+  node_type nh = set.extract(0);
+  BOOST_TEST(nh.empty());
+  BOOST_TEST_EQ(key::count_, 0);
+
+  set.insert(0);
+  set.insert(1);
+  set.insert(2);
+  set.insert(0);
+  set.insert(0);
+  set.insert(0);
+
+  std::size_t const set_size = set.size();
+  int const expected_key_count = key::count_;
+
+  std::size_t count = 0;
+
+  nh = set.extract(0);
+  count = set.count(0);
+  BOOST_TEST_EQ(set.size(), set_size - 1);
+  BOOST_TEST_EQ(nh.value(), 0);
+  BOOST_TEST_EQ(count, set_size - 3);
+
+  set.insert(boost::move(nh));
+
+  nh = set.extract(1);
+  count = set.count(1);
+  BOOST_TEST_EQ(set.size(), set_size - 1);
+  BOOST_TEST_EQ(nh.value(), 1);
+  BOOST_TEST_EQ(count, 0);
+
+  set.insert(boost::move(nh));
+
+  nh = set.extract(1337);
+  BOOST_TEST(nh.empty());
+  BOOST_TEST_EQ(set.size(), set_size);
+
+  BOOST_TEST_EQ(key::count_, expected_key_count);
+}
+
+template <class UnorderedSet> void test_set_non_transparent_extract()
+{
+  typedef typename UnorderedSet::node_type node_type;
+
+  count_reset();
+
+  UnorderedSet set;
+
+  node_type nh = set.extract(0);
+  BOOST_TEST(nh.empty());
+  BOOST_TEST_EQ(key::count_, 1);
+
+  set.insert(0);
+  set.insert(1);
+  set.insert(2);
+  set.insert(0);
+  set.insert(0);
+  set.insert(0);
+
+  std::size_t const set_size = set.size();
+
+  int key_count = key::count_;
+  std::size_t count = 0;
+
+  nh = set.extract(0);
+  ++key_count;
+
+  count = set.count(0);
+  ++key_count;
+
+  BOOST_TEST_EQ(set.size(), set_size - 1);
+  BOOST_TEST_EQ(nh.value(), 0);
+  BOOST_TEST_EQ(count, set_size - 3);
+
+  set.insert(boost::move(nh));
+
+  nh = set.extract(1);
+  ++key_count;
+
+  count = set.count(1);
+  ++key_count;
+
+  BOOST_TEST_EQ(set.size(), set_size - 1);
+  BOOST_TEST_EQ(nh.value(), 1);
+  BOOST_TEST_EQ(count, 0);
+
+  set.insert(boost::move(nh));
+
+  nh = set.extract(1337);
+  ++key_count;
+
+  BOOST_TEST(nh.empty());
+  BOOST_TEST_EQ(set.size(), set_size);
+
+  BOOST_TEST_EQ(key::count_, key_count);
+}
+
 void test_unordered_map()
 {
   {
@@ -1560,6 +1682,7 @@ void test_unordered_set()
     test_set_transparent_find<unordered_set>();
     test_set_transparent_erase<unordered_set>();
     test_set_transparent_equal_range<unordered_set>();
+    test_set_transparent_extract<unordered_set>();
   }
 
   {
@@ -1571,6 +1694,7 @@ void test_unordered_set()
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
     test_set_non_transparent_equal_range<unordered_set>();
+    test_set_non_transparent_extract<unordered_set>();
   }
 
   {
@@ -1583,6 +1707,7 @@ void test_unordered_set()
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
     test_set_non_transparent_equal_range<unordered_set>();
+    test_set_non_transparent_extract<unordered_set>();
   }
 
   {
@@ -1595,6 +1720,7 @@ void test_unordered_set()
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
     test_set_non_transparent_equal_range<unordered_set>();
+    test_set_non_transparent_extract<unordered_set>();
   }
 }