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
30int 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