Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -16,6 +16,7 @@
 // unordered_multiset& operator=(const unordered_multiset& u);
 
 #include <unordered_set>
+#include <set>
 #include <algorithm>
 #include <cassert>
 #include <cfloat>
@@ -63,17 +64,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
@@ -135,17 +167,48 @@
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
@@ -189,17 +252,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -18,6 +18,7 @@
 // unordered_multiset& operator=(unordered_multiset&& u);
 
 #include <unordered_set>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
@@ -64,17 +65,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -16,6 +16,7 @@
 // unordered_multiset(const unordered_multiset& u);
 
 #include <unordered_set>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
@@ -55,17 +56,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
@@ -102,17 +134,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
@@ -148,17 +211,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -16,6 +16,7 @@
 // unordered_multiset(const unordered_multiset& u, const allocator_type& a);
 
 #include <unordered_set>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
@@ -55,17 +56,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(5));
@@ -102,17 +134,48 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -18,6 +18,7 @@
 // unordered_multiset(unordered_multiset&& u, const allocator_type& a);
 
 #include <unordered_set>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
@@ -58,17 +59,48 @@
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
-        assert(*i == 1);
-        ++i;
-        assert(*i == 1);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 2);
-        ++i;
-        assert(*i == 3);
-        ++i;
-        assert(*i == 4);
+        C::const_iterator ie = c.end();
+        std::set<int> s;
+        s.insert(1);
+        s.insert(2);
+        s.insert(3);
+        s.insert(4);
+        while (i != ie)
+        {
+            int iv = *i;
+            assert(s.find(iv) != s.end());
+            switch (iv)
+            {
+                case 1:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 1);
+                        ++i;
+                    }
+                    break;
+                }
+                case 2:
+                {
+                    for ( int ii = 0; ii < 2; ++ii )
+                    {
+                        assert(*i == 2);
+                        ++i;
+                    }
+                    break;
+                }
+                case 3:
+                    assert(*i == 3);
+                    ++i;
+                    break;
+                case 4:
+                    assert(*i == 4);
+                    ++i;
+                    break;
+                default: assert(false);
+            }
+            s.erase(s.find(iv));
+        }
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(12));