1 //===----------------------------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // UNSUPPORTED: c++98, c++03
14 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
15 // class Alloc = allocator<pair<const Key, T>>>
16 // class unordered_multimap
18 // unordered_multimap(unordered_multimap&& u);
20 #include <unordered_map>
27 #include "test_macros.h"
28 #include "../../../test_compare.h"
29 #include "../../../test_hash.h"
30 #include "test_allocator.h"
31 #include "min_allocator.h"
36 typedef std::unordered_multimap<int, std::string,
37 test_hash<std::hash<int> >,
38 test_compare<std::equal_to<int> >,
39 test_allocator<std::pair<const int, std::string> >
43 test_hash<std::hash<int> >(8),
44 test_compare<std::equal_to<int> >(9),
45 test_allocator<std::pair<const int, std::string> >(10)
48 LIBCPP_ASSERT(c.bucket_count() == 7);
49 assert(c.size() == 0);
50 assert(c.hash_function() == test_hash<std::hash<int> >(8));
51 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
52 assert(c.get_allocator() ==
53 (test_allocator<std::pair<const int, std::string> >(10)));
55 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
56 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
57 assert(c.load_factor() == 0);
58 assert(c.max_load_factor() == 1);
63 typedef std::unordered_multimap<int, std::string,
64 test_hash<std::hash<int> >,
65 test_compare<std::equal_to<int> >,
66 test_allocator<std::pair<const int, std::string> >
68 typedef std::pair<int, std::string> P;
78 C c0(a, a + sizeof(a)/sizeof(a[0]),
80 test_hash<std::hash<int> >(8),
81 test_compare<std::equal_to<int> >(9),
82 test_allocator<std::pair<const int, std::string> >(10)
85 LIBCPP_ASSERT(c.bucket_count() == 7);
86 assert(c.size() == 6);
87 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
88 Eq eq = c.equal_range(1);
89 assert(std::distance(eq.first, eq.second) == 2);
90 C::const_iterator i = eq.first;
91 assert(i->first == 1);
92 assert(i->second == "one");
94 assert(i->first == 1);
95 assert(i->second == "four");
96 eq = c.equal_range(2);
97 assert(std::distance(eq.first, eq.second) == 2);
99 assert(i->first == 2);
100 assert(i->second == "two");
102 assert(i->first == 2);
103 assert(i->second == "four");
105 eq = c.equal_range(3);
106 assert(std::distance(eq.first, eq.second) == 1);
108 assert(i->first == 3);
109 assert(i->second == "three");
110 eq = c.equal_range(4);
111 assert(std::distance(eq.first, eq.second) == 1);
113 assert(i->first == 4);
114 assert(i->second == "four");
115 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
116 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
117 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
118 assert(c.max_load_factor() == 1);
119 assert(c.hash_function() == test_hash<std::hash<int> >(8));
120 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
121 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
126 typedef std::unordered_multimap<int, std::string,
127 test_hash<std::hash<int> >,
128 test_compare<std::equal_to<int> >,
129 min_allocator<std::pair<const int, std::string> >
132 test_hash<std::hash<int> >(8),
133 test_compare<std::equal_to<int> >(9),
134 min_allocator<std::pair<const int, std::string> >()
137 LIBCPP_ASSERT(c.bucket_count() == 7);
138 assert(c.size() == 0);
139 assert(c.hash_function() == test_hash<std::hash<int> >(8));
140 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
141 assert(c.get_allocator() ==
142 (min_allocator<std::pair<const int, std::string> >()));
144 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
145 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
146 assert(c.load_factor() == 0);
147 assert(c.max_load_factor() == 1);
152 typedef std::unordered_multimap<int, std::string,
153 test_hash<std::hash<int> >,
154 test_compare<std::equal_to<int> >,
155 min_allocator<std::pair<const int, std::string> >
157 typedef std::pair<int, std::string> P;
167 C c0(a, a + sizeof(a)/sizeof(a[0]),
169 test_hash<std::hash<int> >(8),
170 test_compare<std::equal_to<int> >(9),
171 min_allocator<std::pair<const int, std::string> >()
174 LIBCPP_ASSERT(c.bucket_count() == 7);
175 assert(c.size() == 6);
176 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
177 Eq eq = c.equal_range(1);
178 assert(std::distance(eq.first, eq.second) == 2);
179 C::const_iterator i = eq.first;
180 assert(i->first == 1);
181 assert(i->second == "one");
183 assert(i->first == 1);
184 assert(i->second == "four");
185 eq = c.equal_range(2);
186 assert(std::distance(eq.first, eq.second) == 2);
188 assert(i->first == 2);
189 assert(i->second == "two");
191 assert(i->first == 2);
192 assert(i->second == "four");
194 eq = c.equal_range(3);
195 assert(std::distance(eq.first, eq.second) == 1);
197 assert(i->first == 3);
198 assert(i->second == "three");
199 eq = c.equal_range(4);
200 assert(std::distance(eq.first, eq.second) == 1);
202 assert(i->first == 4);
203 assert(i->second == "four");
204 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
205 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
206 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
207 assert(c.max_load_factor() == 1);
208 assert(c.hash_function() == test_hash<std::hash<int> >(8));
209 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
210 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
214 #if _LIBCPP_DEBUG >= 1
216 std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
217 std::unordered_multimap<int, int>::iterator i = s1.begin();
218 std::pair<const int, int> k = *i;
219 std::unordered_multimap<int, int> s2 = std::move(s1);
222 assert(s2.size() == 2);