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 //===----------------------------------------------------------------------===//
12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
13 // class Alloc = allocator<pair<const Key, T>>>
14 // class unordered_multimap
16 // unordered_multimap(unordered_multimap&& u);
18 #include <unordered_map>
24 #include "../../../test_compare.h"
25 #include "../../../test_hash.h"
26 #include "test_allocator.h"
27 #include "min_allocator.h"
31 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
33 typedef std::unordered_multimap<int, std::string,
34 test_hash<std::hash<int> >,
35 test_compare<std::equal_to<int> >,
36 test_allocator<std::pair<const int, std::string> >
38 typedef std::pair<int, std::string> P;
49 test_hash<std::hash<int> >(8),
50 test_compare<std::equal_to<int> >(9),
51 test_allocator<std::pair<const int, std::string> >(10)
54 assert(c.bucket_count() == 7);
55 assert(c.size() == 0);
56 assert(c.hash_function() == test_hash<std::hash<int> >(8));
57 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
58 assert(c.get_allocator() ==
59 (test_allocator<std::pair<const int, std::string> >(10)));
61 assert(std::distance(c.begin(), c.end()) == c.size());
62 assert(std::distance(c.cbegin(), c.cend()) == c.size());
63 assert(c.load_factor() == 0);
64 assert(c.max_load_factor() == 1);
69 typedef std::unordered_multimap<int, std::string,
70 test_hash<std::hash<int> >,
71 test_compare<std::equal_to<int> >,
72 test_allocator<std::pair<const int, std::string> >
74 typedef std::pair<int, std::string> P;
84 C c0(a, a + sizeof(a)/sizeof(a[0]),
86 test_hash<std::hash<int> >(8),
87 test_compare<std::equal_to<int> >(9),
88 test_allocator<std::pair<const int, std::string> >(10)
91 assert(c.bucket_count() == 7);
92 assert(c.size() == 6);
93 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
94 Eq eq = c.equal_range(1);
95 assert(std::distance(eq.first, eq.second) == 2);
96 C::const_iterator i = eq.first;
97 assert(i->first == 1);
98 assert(i->second == "one");
100 assert(i->first == 1);
101 assert(i->second == "four");
102 eq = c.equal_range(2);
103 assert(std::distance(eq.first, eq.second) == 2);
105 assert(i->first == 2);
106 assert(i->second == "two");
108 assert(i->first == 2);
109 assert(i->second == "four");
111 eq = c.equal_range(3);
112 assert(std::distance(eq.first, eq.second) == 1);
114 assert(i->first == 3);
115 assert(i->second == "three");
116 eq = c.equal_range(4);
117 assert(std::distance(eq.first, eq.second) == 1);
119 assert(i->first == 4);
120 assert(i->second == "four");
121 assert(std::distance(c.begin(), c.end()) == c.size());
122 assert(std::distance(c.cbegin(), c.cend()) == c.size());
123 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
124 assert(c.max_load_factor() == 1);
125 assert(c.hash_function() == test_hash<std::hash<int> >(8));
126 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
127 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
131 #if __cplusplus >= 201103L
133 typedef std::unordered_multimap<int, std::string,
134 test_hash<std::hash<int> >,
135 test_compare<std::equal_to<int> >,
136 min_allocator<std::pair<const int, std::string> >
138 typedef std::pair<int, std::string> P;
149 test_hash<std::hash<int> >(8),
150 test_compare<std::equal_to<int> >(9),
151 min_allocator<std::pair<const int, std::string> >()
154 assert(c.bucket_count() == 7);
155 assert(c.size() == 0);
156 assert(c.hash_function() == test_hash<std::hash<int> >(8));
157 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
158 assert(c.get_allocator() ==
159 (min_allocator<std::pair<const int, std::string> >()));
161 assert(std::distance(c.begin(), c.end()) == c.size());
162 assert(std::distance(c.cbegin(), c.cend()) == c.size());
163 assert(c.load_factor() == 0);
164 assert(c.max_load_factor() == 1);
169 typedef std::unordered_multimap<int, std::string,
170 test_hash<std::hash<int> >,
171 test_compare<std::equal_to<int> >,
172 min_allocator<std::pair<const int, std::string> >
174 typedef std::pair<int, std::string> P;
184 C c0(a, a + sizeof(a)/sizeof(a[0]),
186 test_hash<std::hash<int> >(8),
187 test_compare<std::equal_to<int> >(9),
188 min_allocator<std::pair<const int, std::string> >()
191 assert(c.bucket_count() == 7);
192 assert(c.size() == 6);
193 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
194 Eq eq = c.equal_range(1);
195 assert(std::distance(eq.first, eq.second) == 2);
196 C::const_iterator i = eq.first;
197 assert(i->first == 1);
198 assert(i->second == "one");
200 assert(i->first == 1);
201 assert(i->second == "four");
202 eq = c.equal_range(2);
203 assert(std::distance(eq.first, eq.second) == 2);
205 assert(i->first == 2);
206 assert(i->second == "two");
208 assert(i->first == 2);
209 assert(i->second == "four");
211 eq = c.equal_range(3);
212 assert(std::distance(eq.first, eq.second) == 1);
214 assert(i->first == 3);
215 assert(i->second == "three");
216 eq = c.equal_range(4);
217 assert(std::distance(eq.first, eq.second) == 1);
219 assert(i->first == 4);
220 assert(i->second == "four");
221 assert(std::distance(c.begin(), c.end()) == c.size());
222 assert(std::distance(c.cbegin(), c.cend()) == c.size());
223 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
224 assert(c.max_load_factor() == 1);
225 assert(c.hash_function() == test_hash<std::hash<int> >(8));
226 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
227 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
232 #if _LIBCPP_DEBUG >= 1
234 std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
235 std::unordered_multimap<int, int>::iterator i = s1.begin();
236 std::pair<const int, int> k = *i;
237 std::unordered_multimap<int, int> s2 = std::move(s1);
240 assert(s2.size() == 2);
243 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES