1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <unordered_map>
11
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
15
16// unordered_multimap(unordered_multimap&& u, const allocator_type& a);
17
18#include <iostream>
19
20#include <unordered_map>
21#include <string>
22#include <cassert>
23#include <cfloat>
24#include <cmath>
25#include <cstddef>
26
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"
32
33int main()
34{
35#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
36    {
37        typedef std::pair<int, std::string> P;
38        typedef test_allocator<std::pair<const int, std::string>> A;
39        typedef std::unordered_multimap<int, std::string,
40                                   test_hash<std::hash<int> >,
41                                   test_compare<std::equal_to<int> >,
42                                   A
43                                   > C;
44        P a[] =
45        {
46            P(1, "one"),
47            P(2, "two"),
48            P(3, "three"),
49            P(4, "four"),
50            P(1, "four"),
51            P(2, "four"),
52        };
53        C c0(a, a + sizeof(a)/sizeof(a[0]),
54            7,
55            test_hash<std::hash<int> >(8),
56            test_compare<std::equal_to<int> >(9),
57            A(10)
58           );
59        C c(std::move(c0), A(12));
60        assert(c.bucket_count() >= 7);
61        assert(c.size() == 6);
62        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
63        Eq eq = c.equal_range(1);
64        assert(std::distance(eq.first, eq.second) == 2);
65        C::const_iterator i = eq.first;
66        assert(i->first == 1);
67        assert(i->second == "one");
68        ++i;
69        assert(i->first == 1);
70        assert(i->second == "four");
71        eq = c.equal_range(2);
72        assert(std::distance(eq.first, eq.second) == 2);
73        i = eq.first;
74        assert(i->first == 2);
75        assert(i->second == "two");
76        ++i;
77        assert(i->first == 2);
78        assert(i->second == "four");
79
80        eq = c.equal_range(3);
81        assert(std::distance(eq.first, eq.second) == 1);
82        i = eq.first;
83        assert(i->first == 3);
84        assert(i->second == "three");
85        eq = c.equal_range(4);
86        assert(std::distance(eq.first, eq.second) == 1);
87        i = eq.first;
88        assert(i->first == 4);
89        assert(i->second == "four");
90        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
91        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
92        assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
93        assert(c.max_load_factor() == 1);
94        assert(c.hash_function() == test_hash<std::hash<int> >(8));
95        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
96        assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12)));
97
98        assert(c0.empty());
99    }
100    {
101        typedef std::pair<int, std::string> P;
102        typedef test_allocator<std::pair<const int, std::string>> A;
103        typedef std::unordered_multimap<int, std::string,
104                                   test_hash<std::hash<int> >,
105                                   test_compare<std::equal_to<int> >,
106                                   A
107                                   > C;
108        P a[] =
109        {
110            P(1, "one"),
111            P(2, "two"),
112            P(3, "three"),
113            P(4, "four"),
114            P(1, "four"),
115            P(2, "four"),
116        };
117        C c0(a, a + sizeof(a)/sizeof(a[0]),
118            7,
119            test_hash<std::hash<int> >(8),
120            test_compare<std::equal_to<int> >(9),
121            A(10)
122           );
123        C c(std::move(c0), A(10));
124        LIBCPP_ASSERT(c.bucket_count() == 7);
125        assert(c.size() == 6);
126        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
127        Eq eq = c.equal_range(1);
128        assert(std::distance(eq.first, eq.second) == 2);
129        C::const_iterator i = eq.first;
130        assert(i->first == 1);
131        assert(i->second == "one");
132        ++i;
133        assert(i->first == 1);
134        assert(i->second == "four");
135        eq = c.equal_range(2);
136        assert(std::distance(eq.first, eq.second) == 2);
137        i = eq.first;
138        assert(i->first == 2);
139        assert(i->second == "two");
140        ++i;
141        assert(i->first == 2);
142        assert(i->second == "four");
143
144        eq = c.equal_range(3);
145        assert(std::distance(eq.first, eq.second) == 1);
146        i = eq.first;
147        assert(i->first == 3);
148        assert(i->second == "three");
149        eq = c.equal_range(4);
150        assert(std::distance(eq.first, eq.second) == 1);
151        i = eq.first;
152        assert(i->first == 4);
153        assert(i->second == "four");
154        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
155        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
156        assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
157        assert(c.max_load_factor() == 1);
158        assert(c.hash_function() == test_hash<std::hash<int> >(8));
159        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
160        assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
161
162        assert(c0.empty());
163    }
164#if TEST_STD_VER >= 11
165    {
166        typedef std::pair<int, std::string> P;
167        typedef min_allocator<std::pair<const int, std::string>> A;
168        typedef std::unordered_multimap<int, std::string,
169                                   test_hash<std::hash<int> >,
170                                   test_compare<std::equal_to<int> >,
171                                   A
172                                   > C;
173        P a[] =
174        {
175            P(1, "one"),
176            P(2, "two"),
177            P(3, "three"),
178            P(4, "four"),
179            P(1, "four"),
180            P(2, "four"),
181        };
182        C c0(a, a + sizeof(a)/sizeof(a[0]),
183            7,
184            test_hash<std::hash<int> >(8),
185            test_compare<std::equal_to<int> >(9),
186            A()
187           );
188        C c(std::move(c0), A());
189        LIBCPP_ASSERT(c.bucket_count() == 7);
190        assert(c.size() == 6);
191        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
192        Eq eq = c.equal_range(1);
193        assert(std::distance(eq.first, eq.second) == 2);
194        C::const_iterator i = eq.first;
195        assert(i->first == 1);
196        assert(i->second == "one");
197        ++i;
198        assert(i->first == 1);
199        assert(i->second == "four");
200        eq = c.equal_range(2);
201        assert(std::distance(eq.first, eq.second) == 2);
202        i = eq.first;
203        assert(i->first == 2);
204        assert(i->second == "two");
205        ++i;
206        assert(i->first == 2);
207        assert(i->second == "four");
208
209        eq = c.equal_range(3);
210        assert(std::distance(eq.first, eq.second) == 1);
211        i = eq.first;
212        assert(i->first == 3);
213        assert(i->second == "three");
214        eq = c.equal_range(4);
215        assert(std::distance(eq.first, eq.second) == 1);
216        i = eq.first;
217        assert(i->first == 4);
218        assert(i->second == "four");
219        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
220        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
221        assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
222        assert(c.max_load_factor() == 1);
223        assert(c.hash_function() == test_hash<std::hash<int> >(8));
224        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
225        assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
226
227        assert(c0.empty());
228    }
229    {
230        typedef std::pair<int, std::string> P;
231        typedef explicit_allocator<std::pair<const int, std::string>> A;
232        typedef std::unordered_multimap<int, std::string,
233                                   test_hash<std::hash<int> >,
234                                   test_compare<std::equal_to<int> >,
235                                   A
236                                   > C;
237        P a[] =
238        {
239            P(1, "one"),
240            P(2, "two"),
241            P(3, "three"),
242            P(4, "four"),
243            P(1, "four"),
244            P(2, "four"),
245        };
246        C c0(a, a + sizeof(a)/sizeof(a[0]),
247            7,
248            test_hash<std::hash<int> >(8),
249            test_compare<std::equal_to<int> >(9),
250            A{}
251           );
252        C c(std::move(c0), A());
253        LIBCPP_ASSERT(c.bucket_count() == 7);
254        assert(c.size() == 6);
255        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
256        Eq eq = c.equal_range(1);
257        assert(std::distance(eq.first, eq.second) == 2);
258        C::const_iterator i = eq.first;
259        assert(i->first == 1);
260        assert(i->second == "one");
261        ++i;
262        assert(i->first == 1);
263        assert(i->second == "four");
264        eq = c.equal_range(2);
265        assert(std::distance(eq.first, eq.second) == 2);
266        i = eq.first;
267        assert(i->first == 2);
268        assert(i->second == "two");
269        ++i;
270        assert(i->first == 2);
271        assert(i->second == "four");
272
273        eq = c.equal_range(3);
274        assert(std::distance(eq.first, eq.second) == 1);
275        i = eq.first;
276        assert(i->first == 3);
277        assert(i->second == "three");
278        eq = c.equal_range(4);
279        assert(std::distance(eq.first, eq.second) == 1);
280        i = eq.first;
281        assert(i->first == 4);
282        assert(i->second == "four");
283        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
284        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
285        assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
286        assert(c.max_load_factor() == 1);
287        assert(c.hash_function() == test_hash<std::hash<int> >(8));
288        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
289        assert(c.get_allocator() == A{});
290
291        assert(c0.empty());
292    }
293#endif
294#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
295}
296