[libcxx][test] Fix order checking in some more unordered_multimap tests
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 is a continuation of D54838 and introduces checks verifying that
any iteration will return elements exactly from a set of valid values
and without repetition, but in no particular order.
Thanks to Andrey Maksimov for the patch.
Differential Revision: https://reviews.llvm.org/D56498
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@361414 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/std/containers/check_consecutive.h b/test/std/containers/check_consecutive.h
new file mode 100644
index 0000000..fdd26ad
--- /dev/null
+++ b/test/std/containers/check_consecutive.h
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef CHECK_CONSECUTIVE_H
+#define CHECK_CONSECUTIVE_H
+
+// <unordered_multiset>
+// <unordered_multimap>
+
+#include <cassert>
+#include <set>
+#include <stddef.h>
+
+// Check consecutive equal values in an unordered_multiset iterator
+template <typename Iter>
+void CheckConsecutiveValues(Iter pos, Iter end, typename Iter::value_type value, size_t count)
+{
+ for ( size_t i = 0; i < count; ++i )
+ {
+ assert(pos != end);
+ assert(*pos == value);
+ ++pos;
+ }
+ assert(pos == end || *pos != value);
+}
+
+// Check consecutive equal keys in an unordered_multimap iterator
+template <typename Iter>
+void CheckConsecutiveKeys(Iter pos, Iter end, typename Iter::value_type::first_type key, std::multiset<typename Iter::value_type::second_type>& values)
+{
+ while (!values.empty())
+ {
+ assert(pos != end);
+ assert(pos->first == key);
+ assert(values.find(pos->second) != values.end());
+ values.erase(values.find(pos->second));
+ ++pos;
+ }
+ assert(pos == end || pos->first != key);
+}
+
+#endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index 191dec9..d7f9576 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -16,6 +16,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -23,6 +24,7 @@
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -62,24 +64,17 @@
c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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));
@@ -139,24 +134,17 @@
c = c0;
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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));
@@ -199,24 +187,17 @@
c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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());
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
index 5947905..dc0cbd6 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -18,11 +18,13 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -56,24 +58,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -112,24 +109,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
index 21c791a..4cace19 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -18,12 +18,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -66,24 +68,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -131,24 +128,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -196,24 +188,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -261,24 +248,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index d570162..08b9a85 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -16,12 +16,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -54,24 +56,17 @@
C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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() ==
@@ -108,24 +103,17 @@
C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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() ==
@@ -161,24 +149,17 @@
C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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() ==
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index ebd0471..a3734f5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -16,12 +16,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -54,24 +56,17 @@
C c(c0, test_allocator<std::pair<const int, std::string> >(5));
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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() ==
@@ -108,24 +103,17 @@
C c(c0, min_allocator<std::pair<const int, std::string> >());
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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() ==
@@ -162,24 +150,17 @@
C c(c0, A{});
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
- C::const_iterator i = c.cbegin();
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
- ++i;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
- ++i;
- assert(i->first == 3);
- assert(i->second == "three");
- ++i;
- assert(i->first == 4);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
+ s.insert("three");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
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{});
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
index aba32bf..5309664 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -18,12 +18,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -51,24 +53,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -104,24 +101,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -159,24 +151,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -215,24 +202,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
index 194daf9..3341c58 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -18,12 +18,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -53,24 +55,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -108,24 +105,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
index 4613e3c..4520963 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -18,12 +18,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -54,24 +56,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -110,24 +107,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
index 582b68b..fe647d5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -19,12 +19,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -56,24 +58,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -113,24 +110,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
index 9019d92..55511b0 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -19,12 +19,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -57,24 +59,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -115,24 +112,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -174,24 +166,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
index bfa2327..ede023a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -18,12 +18,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -86,24 +88,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -175,24 +172,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
index d99c2ad..151e06a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -20,12 +20,14 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -62,24 +64,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -126,24 +123,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -190,24 +182,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -254,24 +241,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
index 4b916fa..9c11caa 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -17,6 +17,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -24,6 +25,7 @@
#include "test_macros.h"
#include "test_iterators.h"
+#include "../../../check_consecutive.h"
#include "../../../NotConstructible.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
@@ -54,24 +56,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -110,24 +107,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -167,24 +159,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -225,24 +212,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
index aa45e07..3a7bfd1 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -17,6 +17,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -24,6 +25,7 @@
#include "test_macros.h"
#include "test_iterators.h"
+#include "../../../check_consecutive.h"
#include "../../../NotConstructible.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
@@ -56,24 +58,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -114,24 +111,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
index ee9de7a..1adc823 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -18,6 +18,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -25,6 +26,7 @@
#include "test_macros.h"
#include "test_iterators.h"
+#include "../../../check_consecutive.h"
#include "../../../NotConstructible.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
@@ -58,24 +60,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -117,24 +114,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
index 54c1f1e..5bc0f8a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -18,6 +18,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -26,6 +27,7 @@
#include "test_macros.h"
#include "test_iterators.h"
#include "../../../NotConstructible.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -59,24 +61,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -119,24 +116,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
index 68181d7..7cb7908 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -19,6 +19,7 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cfloat>
#include <cmath>
@@ -27,6 +28,7 @@
#include "test_macros.h"
#include "test_iterators.h"
#include "../../../NotConstructible.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -61,24 +63,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -122,24 +119,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
@@ -183,24 +175,19 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator i = eq.first;
- assert(i->first == 1);
- assert(i->second == "one");
- ++i;
- assert(i->first == 1);
- assert(i->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- i = eq.first;
- assert(i->first == 2);
- assert(i->second == "two");
- ++i;
- assert(i->first == 2);
- assert(i->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- i = eq.first;
+ C::const_iterator i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index 5ab9750..3c1cb13 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -16,9 +16,11 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "min_allocator.h"
struct TemplateConstructor
@@ -48,6 +50,7 @@
C::const_iterator i = c.find(2);
C::const_iterator i_next = i;
++i_next;
+ std::string es = i->second;
C::iterator j = c.erase(i);
assert(j == i_next);
@@ -55,17 +58,15 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::const_iterator k = eq.first;
assert(k->first == 2);
- assert(k->second == "four");
+ assert(k->second == (es == "two" ? "four" : "two"));
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -97,6 +98,7 @@
C::const_iterator i = c.find(2);
C::const_iterator i_next = i;
++i_next;
+ std::string es = i->second;
C::iterator j = c.erase(i);
assert(j == i_next);
@@ -104,17 +106,15 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::const_iterator k = eq.first;
assert(k->first == 2);
- assert(k->second == "four");
+ assert(k->second == (es == "two" ? "four" : "two"));
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index 5e19c97..f13f4bd 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -16,9 +16,11 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "min_allocator.h"
#if TEST_STD_VER >= 11
@@ -57,23 +59,18 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::const_iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
@@ -88,12 +85,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -111,12 +105,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -134,12 +125,9 @@
assert(c.size() == 3);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -152,12 +140,9 @@
assert(c.size() == 3);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -220,23 +205,18 @@
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::const_iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::const_iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
@@ -251,12 +231,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -274,12 +251,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -297,12 +271,9 @@
assert(c.size() == 3);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -315,12 +286,9 @@
assert(c.size() == 3);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index 50f0584..5cea5a5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -16,9 +16,11 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "min_allocator.h"
int main(int, char**)
@@ -44,20 +46,15 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -75,12 +72,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -121,20 +115,15 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
@@ -152,12 +141,9 @@
assert(c.size() == 4);
eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
k = eq.first;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
index 3a3f987..e586512 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -18,9 +18,11 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "test_iterators.h"
#include "min_allocator.h"
@@ -44,23 +46,18 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
@@ -90,23 +87,18 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index 333392a..9ba3708 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -17,9 +17,11 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
+#include "../../../check_consecutive.h"
#include "test_iterators.h"
#include "min_allocator.h"
@@ -43,23 +45,18 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
@@ -90,23 +87,18 @@
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
- C::iterator k = eq.first;
- assert(k->first == 1);
- assert(k->second == "one");
- ++k;
- assert(k->first == 1);
- assert(k->second == "four");
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
- k = eq.first;
- assert(k->first == 2);
- assert(k->second == "two");
- ++k;
- assert(k->first == 2);
- assert(k->second == "four");
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
- k = eq.first;
+ C::iterator k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
eq = c.equal_range(4);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 4069782..9fcd6cc 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -16,10 +16,12 @@
#include <unordered_map>
#include <string>
+#include <set>
#include <cassert>
#include <cstddef>
#include "test_macros.h"
+#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
@@ -134,10 +136,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
@@ -197,10 +202,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
@@ -318,10 +326,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
@@ -381,10 +392,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
@@ -502,10 +516,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
@@ -565,10 +582,13 @@
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::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(1), c2.end(), 1, s);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<C::const_iterator>(c2.find(2), c2.end(), 2, s);
assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1));
