[libcxx] Fix order checking in unordered_multimap tests.

[amakc11]

Summary

Some tests assume that iteration through an unordered multimap elements will return them in the same order as at the container creation. This assumption is not true since the container is unordered, so that no specific order of elements is ever guaranteed for such container. This patch introduces checks verifying that any iteration will return elements exactly from a set of valid values and without repetition, but in no particular order.

[ldionne]

Please make sure you can run the test suite with your patch in C++03 mode.

test/std/containers/unord/unord.multimap/reserve.pass.cpp

31

This is going to fail in C++03 mode because you're using initializer-list construction.

[amakc11]

Hmm, I'm confused by this change request. All the tests I patched are intended to test unordered_multimap container, which was introduced in C++11. So, they won't compile in C++03 mode in any case. Please, clarify the reason for the patch change.

[ldionne]

In D54838#1308564, @amakc11 wrote:

Hmm, I'm confused by this change request. All the tests I patched are intended to test unordered_multimap container, which was introduced in C++11. So, they won't compile in C++03 mode in any case. Please, clarify the reason for the patch change.

We seem to be supporting those containers in C++03 mode, as an extension.

[ldionne]

I just had a discussion with other libc++ maintainers and we'd like to conserve the order-dependent tests, but only for libc++. Could you please keep the order-dependent tests in a suitably-named file under test/libcxx/<...> instead of test/std/<...>? Tests under test/libcxx/ are libc++-specific.

[mclow.lists]

In D54838#1308564, @amakc11 wrote:

Hmm, I'm confused by this change request. All the tests I patched are intended to test unordered_multimap container, which was introduced in C++11. So, they won't compile in C++03 mode in any case. Please, clarify the reason for the patch change.

Libc++ was never a c++03 standard library implementation.
It started out as C++11. We support most of the C++11 features even if the user specifies -std=c++98 or -std=c++03

[amakc11]

Initializer-list construction replaced with insert() throughout the tests.

In D54838#1308594, @ldionne wrote:

Could you please keep the order-dependent tests in a suitably-named file under test/libcxx/<...> instead of test/std/<...>? Tests under test/libcxx/ are libc++-specific.

I would suggest someone from libc++ test suite developers/maintainers team to do this, if it is necessary for them, before the patch is applied to test/std/<...> tests. I'm not a member of this team, but just yet another external user of test/std/<...> tests. So, I'd like to avoid intervening into another expert team's job by trying to solve their internal tasks having no sufficient expertize to do this.

[amakc11]

ping

[amakc11]

Is this patch rejected? BTW, since git repository is used to store tests, the copy of any previous version of the patched tests can be made any time after the patch is applied.

[ldionne]

Merged in r349780.

test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
int main()
         const C c(std::begin(a), std::end(a));
         std::pair<I, I> r = c.equal_range(30);
         assert(std::distance(r.first, r.second) == 1);
         assert(r.first->first == 30);
         assert(r.first->second == "thirty");
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
             assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
             ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        }
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef C::const_iterator I;
         typedef std::pair<int, std::string> P;
         P a[] =
#if TEST_STD_VER >= 11
         const C c(std::begin(a), std::end(a));
         std::pair<I, I> r = c.equal_range(30);
         assert(std::distance(r.first, r.second) == 1);
         assert(r.first->first == 30);
         assert(r.first->second == "thirty");
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
             assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
             ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        }
     }
 #endif
 }

test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // pair<iterator, iterator> equal_range(const key_type& k);
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
int main()
         C c(std::begin(a), std::end(a));
         std::pair<I, I> r = c.equal_range(30);
         assert(std::distance(r.first, r.second) == 1);
         assert(r.first->first == 30);
         assert(r.first->second == "thirty");
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
             assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
             ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        }
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef C::iterator I;
         typedef std::pair<int, std::string> P;
         P a[] =
#if TEST_STD_VER >= 11
         C c(std::begin(a), std::end(a));
         std::pair<I, I> r = c.equal_range(30);
         assert(std::distance(r.first, r.second) == 1);
         assert(r.first->first == 30);
         assert(r.first->second == "thirty");
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
             assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
             ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        }
     }
 #endif
 }

test/std/containers/unord/unord.multimap/local_iterators.pass.cpp

 // local_iterator       end   (size_type n);
 // const_local_iterator begin (size_type n) const;
 // const_local_iterator end   (size_type n) const;
 // const_local_iterator cbegin(size_type n) const;
 // const_local_iterator cend  (size_type n) const;
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
int main()
         I i = c.begin(b);
         I j = c.end(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
int main()
         I i = c.begin(b);
         I j = c.end(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
int main()
         I i = c.cbegin(b);
         I j = c.cend(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
int main()
         I i = c.cbegin(b);
         I j = c.cend(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
#if TEST_STD_VER >= 11
         I i = c.begin(b);
         I j = c.end(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
#if TEST_STD_VER >= 11
         I i = c.begin(b);
         I j = c.end(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
#if TEST_STD_VER >= 11
         I i = c.cbegin(b);
         I j = c.cend(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 
#if TEST_STD_VER >= 11
         I i = c.cbegin(b);
         I j = c.cend(b);
         assert(std::distance(i, j) == 0);
 
         b = c.bucket(1);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 1);
-        assert(i->second == "one");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
                 assert(i->first == 2);
-        assert(i->second == "two");
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
                 ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 1);
         assert(i->first == 3);
         assert(i->second == "three");
 

test/std/containers/unord/unord.multimap/rehash.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // void rehash(size_type n);
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
     assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
 }
 
 template <class C>
 void test(const C& c)
 {
     assert(c.size() == 6);
     typedef std::pair<typename C::const_iterator, typename C::const_iterator> Eq;
     Eq eq = c.equal_range(1);
     assert(std::distance(eq.first, eq.second) == 2);
     typename C::const_iterator i = eq.first;
+    {
+        std::set<std::string> s;
+        s.insert("one");
+        s.insert("four");
+        for ( int n = 0; n < 2; ++n )
+        {
             assert(i->first == 1);
-    assert(i->second == "one");
+            assert(s.find(i->second) != s.end());
+            s.erase(s.find(i->second));
             ++i;
-    assert(i->first == 1);
-    assert(i->second == "four");
+        }
+    }
     eq = c.equal_range(2);
     assert(std::distance(eq.first, eq.second) == 2);
     i = eq.first;
+    {
+        std::set<std::string> s;
+        s.insert("two");
+        s.insert("four");
+        for ( int n = 0; n < 2; ++n )
+        {
             assert(i->first == 2);
-    assert(i->second == "two");
+            assert(s.find(i->second) != s.end());
+            s.erase(s.find(i->second));
             ++i;
-    assert(i->first == 2);
-    assert(i->second == "four");
-
+        }
+    }
     eq = c.equal_range(3);
     assert(std::distance(eq.first, eq.second) == 1);
     i = eq.first;
     assert(i->first == 3);
     assert(i->second == "three");
     eq = c.equal_range(4);
     assert(std::distance(eq.first, eq.second) == 1);
     i = eq.first;

test/std/containers/unord/unord.multimap/reserve.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
-// void rehash(size_type n);
+// void reserve(size_type n);
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 void test(const C& c)
 {
     assert(c.size() == 6);
-    assert(c.find(1)->second == "one");
-    assert(next(c.find(1))->second == "four");
-    assert(c.find(2)->second == "two");
-    assert(next(c.find(2))->second == "four");
+    {
+        std::set<std::string> s;
+        s.insert("one");
+        s.insert("four");
+        assert(s.find(c.find(1)->second) != s.end());
+        s.erase(s.find(c.find(1)->second));
+        assert(s.find(next(c.find(1))->second) != s.end());
+    }
+    {
+        std::set<std::string> s;
+        s.insert("two");
+        s.insert("four");
+        assert(s.find(c.find(2)->second) != s.end());
+        s.erase(s.find(c.find(2)->second));
+        assert(s.find(next(c.find(2))->second) != s.end());
+    }
     assert(c.find(3)->second == "three");
     assert(c.find(4)->second == "four");
 }
 
 void reserve_invariant(size_t n) // LWG #2156
 {
     for (size_t i = 0; i < n; ++i)
     {

test/std/containers/unord/unord.multimap/swap_member.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // void swap(unordered_multimap& __u);
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
 
int main()
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator().get_id() == 1);
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator().get_id() == 2);
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
int main()
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator().get_id() == 1);
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator().get_id() == 2);
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
int main()
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
int main()
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
#if TEST_STD_VER >= 11
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
#if TEST_STD_VER >= 11
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
 }