[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 = {"fifty", "fiftyA", "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 = {"fifty", "fiftyA", "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 = {"fifty", "fiftyA", "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 = {"fifty", "fiftyA", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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 = {"one", "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 = {"two", "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
 }