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 // void swap(unordered_multimap& __u);
17
18 #include <unordered_map>
19 #include <string>
20 #include <cassert>
21 #include <cstddef>
22
23 #include "test_macros.h"
24 #include "../../test_compare.h"
25 #include "../../test_hash.h"
26 #include "test_allocator.h"
27
28 #include "min_allocator.h"
29
main()30 int main()
31 {
32 {
33 typedef test_hash<std::hash<int> > Hash;
34 typedef test_compare<std::equal_to<int> > Compare;
35 typedef test_allocator<std::pair<const int, std::string> > Alloc;
36 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
37 C c1(0, Hash(1), Compare(1), Alloc(1, 1));
38 C c2(0, Hash(2), Compare(2), Alloc(1, 2));
39 c2.max_load_factor(2);
40 c1.swap(c2);
41
42 LIBCPP_ASSERT(c1.bucket_count() == 0);
43 assert(c1.size() == 0);
44 assert(c1.hash_function() == Hash(2));
45 assert(c1.key_eq() == Compare(2));
46 assert(c1.get_allocator().get_id() == 1);
47 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
48 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
49 assert(c1.max_load_factor() == 2);
50
51 LIBCPP_ASSERT(c2.bucket_count() == 0);
52 assert(c2.size() == 0);
53 assert(c2.hash_function() == Hash(1));
54 assert(c2.key_eq() == Compare(1));
55 assert(c2.get_allocator().get_id() == 2);
56 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
57 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
58 assert(c2.max_load_factor() == 1);
59 }
60 {
61 typedef test_hash<std::hash<int> > Hash;
62 typedef test_compare<std::equal_to<int> > Compare;
63 typedef test_allocator<std::pair<const int, std::string> > Alloc;
64 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
65 typedef std::pair<int, std::string> P;
66 P a2[] =
67 {
68 P(10, "ten"),
69 P(20, "twenty"),
70 P(30, "thirty"),
71 P(40, "forty"),
72 P(50, "fifty"),
73 P(60, "sixty"),
74 P(70, "seventy"),
75 P(80, "eighty"),
76 };
77 C c1(0, Hash(1), Compare(1), Alloc(1, 1));
78 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
79 c2.max_load_factor(2);
80 c1.swap(c2);
81
82 assert(c1.bucket_count() >= 8);
83 assert(c1.size() == 8);
84 assert(c1.find(10)->second == "ten");
85 assert(c1.find(20)->second == "twenty");
86 assert(c1.find(30)->second == "thirty");
87 assert(c1.find(40)->second == "forty");
88 assert(c1.find(50)->second == "fifty");
89 assert(c1.find(60)->second == "sixty");
90 assert(c1.find(70)->second == "seventy");
91 assert(c1.find(80)->second == "eighty");
92 assert(c1.hash_function() == Hash(2));
93 assert(c1.key_eq() == Compare(2));
94 assert(c1.get_allocator().get_id() == 1);
95 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
96 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
97 assert(c1.max_load_factor() == 2);
98
99 LIBCPP_ASSERT(c2.bucket_count() == 0);
100 assert(c2.size() == 0);
101 assert(c2.hash_function() == Hash(1));
102 assert(c2.key_eq() == Compare(1));
103 assert(c2.get_allocator().get_id() == 2);
104 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
105 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
106 assert(c2.max_load_factor() == 1);
107 }
108 {
109 typedef test_hash<std::hash<int> > Hash;
110 typedef test_compare<std::equal_to<int> > Compare;
111 typedef test_allocator<std::pair<const int, std::string> > Alloc;
112 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
113 typedef std::pair<int, std::string> P;
114 P a1[] =
115 {
116 P(1, "one"),
117 P(2, "two"),
118 P(3, "three"),
119 P(4, "four"),
120 P(1, "four"),
121 P(2, "four"),
122 };
123 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
124 C c2(0, Hash(2), Compare(2), Alloc(1, 2));
125 c2.max_load_factor(2);
126 c1.swap(c2);
127
128 LIBCPP_ASSERT(c1.bucket_count() == 0);
129 assert(c1.size() == 0);
130 assert(c1.hash_function() == Hash(2));
131 assert(c1.key_eq() == Compare(2));
132 assert(c1.get_allocator().get_id() == 1);
133 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
134 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
135 assert(c1.max_load_factor() == 2);
136
137 assert(c2.bucket_count() >= 6);
138 assert(c2.size() == 6);
139 assert(c2.find(1)->second == "one");
140 assert(next(c2.find(1))->second == "four");
141 assert(c2.find(2)->second == "two");
142 assert(next(c2.find(2))->second == "four");
143 assert(c2.find(3)->second == "three");
144 assert(c2.find(4)->second == "four");
145 assert(c2.hash_function() == Hash(1));
146 assert(c2.key_eq() == Compare(1));
147 assert(c2.get_allocator().get_id() == 2);
148 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
149 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
150 assert(c2.max_load_factor() == 1);
151 }
152 {
153 typedef test_hash<std::hash<int> > Hash;
154 typedef test_compare<std::equal_to<int> > Compare;
155 typedef test_allocator<std::pair<const int, std::string> > Alloc;
156 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
157 typedef std::pair<int, std::string> P;
158 P a1[] =
159 {
160 P(1, "one"),
161 P(2, "two"),
162 P(3, "three"),
163 P(4, "four"),
164 P(1, "four"),
165 P(2, "four"),
166 };
167 P a2[] =
168 {
169 P(10, "ten"),
170 P(20, "twenty"),
171 P(30, "thirty"),
172 P(40, "forty"),
173 P(50, "fifty"),
174 P(60, "sixty"),
175 P(70, "seventy"),
176 P(80, "eighty"),
177 };
178 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
179 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
180 c2.max_load_factor(2);
181 c1.swap(c2);
182
183 assert(c1.bucket_count() >= 8);
184 assert(c1.size() == 8);
185 assert(c1.find(10)->second == "ten");
186 assert(c1.find(20)->second == "twenty");
187 assert(c1.find(30)->second == "thirty");
188 assert(c1.find(40)->second == "forty");
189 assert(c1.find(50)->second == "fifty");
190 assert(c1.find(60)->second == "sixty");
191 assert(c1.find(70)->second == "seventy");
192 assert(c1.find(80)->second == "eighty");
193 assert(c1.hash_function() == Hash(2));
194 assert(c1.key_eq() == Compare(2));
195 assert(c1.get_allocator().get_id() == 1);
196 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
197 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
198 assert(c1.max_load_factor() == 2);
199
200 assert(c2.bucket_count() >= 6);
201 assert(c2.size() == 6);
202 assert(c2.find(1)->second == "one");
203 assert(next(c2.find(1))->second == "four");
204 assert(c2.find(2)->second == "two");
205 assert(next(c2.find(2))->second == "four");
206 assert(c2.find(3)->second == "three");
207 assert(c2.find(4)->second == "four");
208 assert(c2.hash_function() == Hash(1));
209 assert(c2.key_eq() == Compare(1));
210 assert(c2.get_allocator().get_id() == 2);
211 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
212 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
213 assert(c2.max_load_factor() == 1);
214 }
215
216 {
217 typedef test_hash<std::hash<int> > Hash;
218 typedef test_compare<std::equal_to<int> > Compare;
219 typedef other_allocator<std::pair<const int, std::string> > Alloc;
220 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
221 C c1(0, Hash(1), Compare(1), Alloc(1));
222 C c2(0, Hash(2), Compare(2), Alloc(2));
223 c2.max_load_factor(2);
224 c1.swap(c2);
225
226 LIBCPP_ASSERT(c1.bucket_count() == 0);
227 assert(c1.size() == 0);
228 assert(c1.hash_function() == Hash(2));
229 assert(c1.key_eq() == Compare(2));
230 assert(c1.get_allocator() == Alloc(2));
231 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
232 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
233 assert(c1.max_load_factor() == 2);
234
235 LIBCPP_ASSERT(c2.bucket_count() == 0);
236 assert(c2.size() == 0);
237 assert(c2.hash_function() == Hash(1));
238 assert(c2.key_eq() == Compare(1));
239 assert(c2.get_allocator() == Alloc(1));
240 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
241 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
242 assert(c2.max_load_factor() == 1);
243 }
244 {
245 typedef test_hash<std::hash<int> > Hash;
246 typedef test_compare<std::equal_to<int> > Compare;
247 typedef other_allocator<std::pair<const int, std::string> > Alloc;
248 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
249 typedef std::pair<int, std::string> P;
250 P a2[] =
251 {
252 P(10, "ten"),
253 P(20, "twenty"),
254 P(30, "thirty"),
255 P(40, "forty"),
256 P(50, "fifty"),
257 P(60, "sixty"),
258 P(70, "seventy"),
259 P(80, "eighty"),
260 };
261 C c1(0, Hash(1), Compare(1), Alloc(1));
262 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
263 c2.max_load_factor(2);
264 c1.swap(c2);
265
266 assert(c1.bucket_count() >= 8);
267 assert(c1.size() == 8);
268 assert(c1.find(10)->second == "ten");
269 assert(c1.find(20)->second == "twenty");
270 assert(c1.find(30)->second == "thirty");
271 assert(c1.find(40)->second == "forty");
272 assert(c1.find(50)->second == "fifty");
273 assert(c1.find(60)->second == "sixty");
274 assert(c1.find(70)->second == "seventy");
275 assert(c1.find(80)->second == "eighty");
276 assert(c1.hash_function() == Hash(2));
277 assert(c1.key_eq() == Compare(2));
278 assert(c1.get_allocator() == Alloc(2));
279 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
280 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
281 assert(c1.max_load_factor() == 2);
282
283 LIBCPP_ASSERT(c2.bucket_count() == 0);
284 assert(c2.size() == 0);
285 assert(c2.hash_function() == Hash(1));
286 assert(c2.key_eq() == Compare(1));
287 assert(c2.get_allocator() == Alloc(1));
288 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
289 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
290 assert(c2.max_load_factor() == 1);
291 }
292 {
293 typedef test_hash<std::hash<int> > Hash;
294 typedef test_compare<std::equal_to<int> > Compare;
295 typedef other_allocator<std::pair<const int, std::string> > Alloc;
296 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
297 typedef std::pair<int, std::string> P;
298 P a1[] =
299 {
300 P(1, "one"),
301 P(2, "two"),
302 P(3, "three"),
303 P(4, "four"),
304 P(1, "four"),
305 P(2, "four"),
306 };
307 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
308 C c2(0, Hash(2), Compare(2), Alloc(2));
309 c2.max_load_factor(2);
310 c1.swap(c2);
311
312 LIBCPP_ASSERT(c1.bucket_count() == 0);
313 assert(c1.size() == 0);
314 assert(c1.hash_function() == Hash(2));
315 assert(c1.key_eq() == Compare(2));
316 assert(c1.get_allocator() == Alloc(2));
317 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
318 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
319 assert(c1.max_load_factor() == 2);
320
321 assert(c2.bucket_count() >= 6);
322 assert(c2.size() == 6);
323 assert(c2.find(1)->second == "one");
324 assert(next(c2.find(1))->second == "four");
325 assert(c2.find(2)->second == "two");
326 assert(next(c2.find(2))->second == "four");
327 assert(c2.find(3)->second == "three");
328 assert(c2.find(4)->second == "four");
329 assert(c2.hash_function() == Hash(1));
330 assert(c2.key_eq() == Compare(1));
331 assert(c2.get_allocator() == Alloc(1));
332 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
333 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
334 assert(c2.max_load_factor() == 1);
335 }
336 {
337 typedef test_hash<std::hash<int> > Hash;
338 typedef test_compare<std::equal_to<int> > Compare;
339 typedef other_allocator<std::pair<const int, std::string> > Alloc;
340 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
341 typedef std::pair<int, std::string> P;
342 P a1[] =
343 {
344 P(1, "one"),
345 P(2, "two"),
346 P(3, "three"),
347 P(4, "four"),
348 P(1, "four"),
349 P(2, "four"),
350 };
351 P a2[] =
352 {
353 P(10, "ten"),
354 P(20, "twenty"),
355 P(30, "thirty"),
356 P(40, "forty"),
357 P(50, "fifty"),
358 P(60, "sixty"),
359 P(70, "seventy"),
360 P(80, "eighty"),
361 };
362 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
363 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
364 c2.max_load_factor(2);
365 c1.swap(c2);
366
367 assert(c1.bucket_count() >= 8);
368 assert(c1.size() == 8);
369 assert(c1.find(10)->second == "ten");
370 assert(c1.find(20)->second == "twenty");
371 assert(c1.find(30)->second == "thirty");
372 assert(c1.find(40)->second == "forty");
373 assert(c1.find(50)->second == "fifty");
374 assert(c1.find(60)->second == "sixty");
375 assert(c1.find(70)->second == "seventy");
376 assert(c1.find(80)->second == "eighty");
377 assert(c1.hash_function() == Hash(2));
378 assert(c1.key_eq() == Compare(2));
379 assert(c1.get_allocator() == Alloc(2));
380 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
381 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
382 assert(c1.max_load_factor() == 2);
383
384 assert(c2.bucket_count() >= 6);
385 assert(c2.size() == 6);
386 assert(c2.find(1)->second == "one");
387 assert(next(c2.find(1))->second == "four");
388 assert(c2.find(2)->second == "two");
389 assert(next(c2.find(2))->second == "four");
390 assert(c2.find(3)->second == "three");
391 assert(c2.find(4)->second == "four");
392 assert(c2.hash_function() == Hash(1));
393 assert(c2.key_eq() == Compare(1));
394 assert(c2.get_allocator() == Alloc(1));
395 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
396 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
397 assert(c2.max_load_factor() == 1);
398 }
399 #if TEST_STD_VER >= 11
400 {
401 typedef test_hash<std::hash<int> > Hash;
402 typedef test_compare<std::equal_to<int> > Compare;
403 typedef min_allocator<std::pair<const int, std::string> > Alloc;
404 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
405 C c1(0, Hash(1), Compare(1), Alloc());
406 C c2(0, Hash(2), Compare(2), Alloc());
407 c2.max_load_factor(2);
408 c1.swap(c2);
409
410 LIBCPP_ASSERT(c1.bucket_count() == 0);
411 assert(c1.size() == 0);
412 assert(c1.hash_function() == Hash(2));
413 assert(c1.key_eq() == Compare(2));
414 assert(c1.get_allocator() == Alloc());
415 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
416 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
417 assert(c1.max_load_factor() == 2);
418
419 LIBCPP_ASSERT(c2.bucket_count() == 0);
420 assert(c2.size() == 0);
421 assert(c2.hash_function() == Hash(1));
422 assert(c2.key_eq() == Compare(1));
423 assert(c2.get_allocator() == Alloc());
424 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
425 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
426 assert(c2.max_load_factor() == 1);
427 }
428 {
429 typedef test_hash<std::hash<int> > Hash;
430 typedef test_compare<std::equal_to<int> > Compare;
431 typedef min_allocator<std::pair<const int, std::string> > Alloc;
432 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
433 typedef std::pair<int, std::string> P;
434 P a2[] =
435 {
436 P(10, "ten"),
437 P(20, "twenty"),
438 P(30, "thirty"),
439 P(40, "forty"),
440 P(50, "fifty"),
441 P(60, "sixty"),
442 P(70, "seventy"),
443 P(80, "eighty"),
444 };
445 C c1(0, Hash(1), Compare(1), Alloc());
446 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
447 c2.max_load_factor(2);
448 c1.swap(c2);
449
450 assert(c1.bucket_count() >= 8);
451 assert(c1.size() == 8);
452 assert(c1.find(10)->second == "ten");
453 assert(c1.find(20)->second == "twenty");
454 assert(c1.find(30)->second == "thirty");
455 assert(c1.find(40)->second == "forty");
456 assert(c1.find(50)->second == "fifty");
457 assert(c1.find(60)->second == "sixty");
458 assert(c1.find(70)->second == "seventy");
459 assert(c1.find(80)->second == "eighty");
460 assert(c1.hash_function() == Hash(2));
461 assert(c1.key_eq() == Compare(2));
462 assert(c1.get_allocator() == Alloc());
463 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
464 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
465 assert(c1.max_load_factor() == 2);
466
467 LIBCPP_ASSERT(c2.bucket_count() == 0);
468 assert(c2.size() == 0);
469 assert(c2.hash_function() == Hash(1));
470 assert(c2.key_eq() == Compare(1));
471 assert(c2.get_allocator() == Alloc());
472 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
473 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
474 assert(c2.max_load_factor() == 1);
475 }
476 {
477 typedef test_hash<std::hash<int> > Hash;
478 typedef test_compare<std::equal_to<int> > Compare;
479 typedef min_allocator<std::pair<const int, std::string> > Alloc;
480 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
481 typedef std::pair<int, std::string> P;
482 P a1[] =
483 {
484 P(1, "one"),
485 P(2, "two"),
486 P(3, "three"),
487 P(4, "four"),
488 P(1, "four"),
489 P(2, "four"),
490 };
491 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
492 C c2(0, Hash(2), Compare(2), Alloc());
493 c2.max_load_factor(2);
494 c1.swap(c2);
495
496 LIBCPP_ASSERT(c1.bucket_count() == 0);
497 assert(c1.size() == 0);
498 assert(c1.hash_function() == Hash(2));
499 assert(c1.key_eq() == Compare(2));
500 assert(c1.get_allocator() == Alloc());
501 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
502 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
503 assert(c1.max_load_factor() == 2);
504
505 assert(c2.bucket_count() >= 6);
506 assert(c2.size() == 6);
507 assert(c2.find(1)->second == "one");
508 assert(next(c2.find(1))->second == "four");
509 assert(c2.find(2)->second == "two");
510 assert(next(c2.find(2))->second == "four");
511 assert(c2.find(3)->second == "three");
512 assert(c2.find(4)->second == "four");
513 assert(c2.hash_function() == Hash(1));
514 assert(c2.key_eq() == Compare(1));
515 assert(c2.get_allocator() == Alloc());
516 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
517 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
518 assert(c2.max_load_factor() == 1);
519 }
520 {
521 typedef test_hash<std::hash<int> > Hash;
522 typedef test_compare<std::equal_to<int> > Compare;
523 typedef min_allocator<std::pair<const int, std::string> > Alloc;
524 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
525 typedef std::pair<int, std::string> P;
526 P a1[] =
527 {
528 P(1, "one"),
529 P(2, "two"),
530 P(3, "three"),
531 P(4, "four"),
532 P(1, "four"),
533 P(2, "four"),
534 };
535 P a2[] =
536 {
537 P(10, "ten"),
538 P(20, "twenty"),
539 P(30, "thirty"),
540 P(40, "forty"),
541 P(50, "fifty"),
542 P(60, "sixty"),
543 P(70, "seventy"),
544 P(80, "eighty"),
545 };
546 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
547 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
548 c2.max_load_factor(2);
549 c1.swap(c2);
550
551 assert(c1.bucket_count() >= 8);
552 assert(c1.size() == 8);
553 assert(c1.find(10)->second == "ten");
554 assert(c1.find(20)->second == "twenty");
555 assert(c1.find(30)->second == "thirty");
556 assert(c1.find(40)->second == "forty");
557 assert(c1.find(50)->second == "fifty");
558 assert(c1.find(60)->second == "sixty");
559 assert(c1.find(70)->second == "seventy");
560 assert(c1.find(80)->second == "eighty");
561 assert(c1.hash_function() == Hash(2));
562 assert(c1.key_eq() == Compare(2));
563 assert(c1.get_allocator() == Alloc());
564 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
565 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
566 assert(c1.max_load_factor() == 2);
567
568 assert(c2.bucket_count() >= 6);
569 assert(c2.size() == 6);
570 assert(c2.find(1)->second == "one");
571 assert(next(c2.find(1))->second == "four");
572 assert(c2.find(2)->second == "two");
573 assert(next(c2.find(2))->second == "four");
574 assert(c2.find(3)->second == "three");
575 assert(c2.find(4)->second == "four");
576 assert(c2.hash_function() == Hash(1));
577 assert(c2.key_eq() == Compare(1));
578 assert(c2.get_allocator() == Alloc());
579 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
580 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
581 assert(c2.max_load_factor() == 1);
582 }
583 #endif
584 }
585