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
22#include "../../test_compare.h"
23#include "../../test_hash.h"
24#include "test_allocator.h"
25
26#include "min_allocator.h"
27
28int main()
29{
30    {
31        typedef test_hash<std::hash<int> > Hash;
32        typedef test_compare<std::equal_to<int> > Compare;
33        typedef test_allocator<std::pair<const int, std::string> > Alloc;
34        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
35        typedef std::pair<int, std::string> P;
36        C c1(0, Hash(1), Compare(1), Alloc(1));
37        C c2(0, Hash(2), Compare(2), Alloc(2));
38        c2.max_load_factor(2);
39        c1.swap(c2);
40
41        assert(c1.bucket_count() == 0);
42        assert(c1.size() == 0);
43        assert(c1.hash_function() == Hash(2));
44        assert(c1.key_eq() == Compare(2));
45        assert(c1.get_allocator() == Alloc(1));
46        assert(std::distance(c1.begin(), c1.end()) == c1.size());
47        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
48        assert(c1.max_load_factor() == 2);
49
50        assert(c2.bucket_count() == 0);
51        assert(c2.size() == 0);
52        assert(c2.hash_function() == Hash(1));
53        assert(c2.key_eq() == Compare(1));
54        assert(c2.get_allocator() == Alloc(2));
55        assert(std::distance(c2.begin(), c2.end()) == c2.size());
56        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
57        assert(c2.max_load_factor() == 1);
58    }
59    {
60        typedef test_hash<std::hash<int> > Hash;
61        typedef test_compare<std::equal_to<int> > Compare;
62        typedef test_allocator<std::pair<const int, std::string> > Alloc;
63        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
64        typedef std::pair<int, std::string> P;
65        P a2[] =
66        {
67            P(10, "ten"),
68            P(20, "twenty"),
69            P(30, "thirty"),
70            P(40, "forty"),
71            P(50, "fifty"),
72            P(60, "sixty"),
73            P(70, "seventy"),
74            P(80, "eighty"),
75        };
76        C c1(0, Hash(1), Compare(1), Alloc(1));
77        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
78        c2.max_load_factor(2);
79        c1.swap(c2);
80
81        assert(c1.bucket_count() >= 11);
82        assert(c1.size() == 8);
83        assert(c1.find(10)->second == "ten");
84        assert(c1.find(20)->second == "twenty");
85        assert(c1.find(30)->second == "thirty");
86        assert(c1.find(40)->second == "forty");
87        assert(c1.find(50)->second == "fifty");
88        assert(c1.find(60)->second == "sixty");
89        assert(c1.find(70)->second == "seventy");
90        assert(c1.find(80)->second == "eighty");
91        assert(c1.hash_function() == Hash(2));
92        assert(c1.key_eq() == Compare(2));
93        assert(c1.get_allocator() == Alloc(1));
94        assert(std::distance(c1.begin(), c1.end()) == c1.size());
95        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
96        assert(c1.max_load_factor() == 2);
97
98        assert(c2.bucket_count() == 0);
99        assert(c2.size() == 0);
100        assert(c2.hash_function() == Hash(1));
101        assert(c2.key_eq() == Compare(1));
102        assert(c2.get_allocator() == Alloc(2));
103        assert(std::distance(c2.begin(), c2.end()) == c2.size());
104        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
105        assert(c2.max_load_factor() == 1);
106    }
107    {
108        typedef test_hash<std::hash<int> > Hash;
109        typedef test_compare<std::equal_to<int> > Compare;
110        typedef test_allocator<std::pair<const int, std::string> > Alloc;
111        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
112        typedef std::pair<int, std::string> P;
113        P a1[] =
114        {
115            P(1, "one"),
116            P(2, "two"),
117            P(3, "three"),
118            P(4, "four"),
119            P(1, "four"),
120            P(2, "four"),
121        };
122        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
123        C c2(0, Hash(2), Compare(2), Alloc(2));
124        c2.max_load_factor(2);
125        c1.swap(c2);
126
127        assert(c1.bucket_count() == 0);
128        assert(c1.size() == 0);
129        assert(c1.hash_function() == Hash(2));
130        assert(c1.key_eq() == Compare(2));
131        assert(c1.get_allocator() == Alloc(1));
132        assert(std::distance(c1.begin(), c1.end()) == c1.size());
133        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
134        assert(c1.max_load_factor() == 2);
135
136        assert(c2.bucket_count() >= 7);
137        assert(c2.size() == 6);
138        assert(c2.find(1)->second == "one");
139        assert(next(c2.find(1))->second == "four");
140        assert(c2.find(2)->second == "two");
141        assert(next(c2.find(2))->second == "four");
142        assert(c2.find(3)->second == "three");
143        assert(c2.find(4)->second == "four");
144        assert(c2.hash_function() == Hash(1));
145        assert(c2.key_eq() == Compare(1));
146        assert(c2.get_allocator() == Alloc(2));
147        assert(std::distance(c2.begin(), c2.end()) == c2.size());
148        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
149        assert(c2.max_load_factor() == 1);
150    }
151    {
152        typedef test_hash<std::hash<int> > Hash;
153        typedef test_compare<std::equal_to<int> > Compare;
154        typedef test_allocator<std::pair<const int, std::string> > Alloc;
155        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
156        typedef std::pair<int, std::string> P;
157        P a1[] =
158        {
159            P(1, "one"),
160            P(2, "two"),
161            P(3, "three"),
162            P(4, "four"),
163            P(1, "four"),
164            P(2, "four"),
165        };
166        P a2[] =
167        {
168            P(10, "ten"),
169            P(20, "twenty"),
170            P(30, "thirty"),
171            P(40, "forty"),
172            P(50, "fifty"),
173            P(60, "sixty"),
174            P(70, "seventy"),
175            P(80, "eighty"),
176        };
177        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
178        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
179        c2.max_load_factor(2);
180        c1.swap(c2);
181
182        assert(c1.bucket_count() >= 11);
183        assert(c1.size() == 8);
184        assert(c1.find(10)->second == "ten");
185        assert(c1.find(20)->second == "twenty");
186        assert(c1.find(30)->second == "thirty");
187        assert(c1.find(40)->second == "forty");
188        assert(c1.find(50)->second == "fifty");
189        assert(c1.find(60)->second == "sixty");
190        assert(c1.find(70)->second == "seventy");
191        assert(c1.find(80)->second == "eighty");
192        assert(c1.hash_function() == Hash(2));
193        assert(c1.key_eq() == Compare(2));
194        assert(c1.get_allocator() == Alloc(1));
195        assert(std::distance(c1.begin(), c1.end()) == c1.size());
196        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
197        assert(c1.max_load_factor() == 2);
198
199        assert(c2.bucket_count() >= 7);
200        assert(c2.size() == 6);
201        assert(c2.find(1)->second == "one");
202        assert(next(c2.find(1))->second == "four");
203        assert(c2.find(2)->second == "two");
204        assert(next(c2.find(2))->second == "four");
205        assert(c2.find(3)->second == "three");
206        assert(c2.find(4)->second == "four");
207        assert(c2.hash_function() == Hash(1));
208        assert(c2.key_eq() == Compare(1));
209        assert(c2.get_allocator() == Alloc(2));
210        assert(std::distance(c2.begin(), c2.end()) == c2.size());
211        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
212        assert(c2.max_load_factor() == 1);
213    }
214
215    {
216        typedef test_hash<std::hash<int> > Hash;
217        typedef test_compare<std::equal_to<int> > Compare;
218        typedef other_allocator<std::pair<const int, std::string> > Alloc;
219        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
220        typedef std::pair<int, std::string> P;
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        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(std::distance(c1.begin(), c1.end()) == c1.size());
232        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
233        assert(c1.max_load_factor() == 2);
234
235        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(std::distance(c2.begin(), c2.end()) == c2.size());
241        assert(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() >= 11);
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(std::distance(c1.begin(), c1.end()) == c1.size());
280        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
281        assert(c1.max_load_factor() == 2);
282
283        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(std::distance(c2.begin(), c2.end()) == c2.size());
289        assert(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        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(std::distance(c1.begin(), c1.end()) == c1.size());
318        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
319        assert(c1.max_load_factor() == 2);
320
321        assert(c2.bucket_count() >= 7);
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(std::distance(c2.begin(), c2.end()) == c2.size());
333        assert(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() >= 11);
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(std::distance(c1.begin(), c1.end()) == c1.size());
381        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
382        assert(c1.max_load_factor() == 2);
383
384        assert(c2.bucket_count() >= 7);
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(std::distance(c2.begin(), c2.end()) == c2.size());
396        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
397        assert(c2.max_load_factor() == 1);
398    }
399#if __cplusplus >= 201103L
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        typedef std::pair<int, std::string> P;
406        C c1(0, Hash(1), Compare(1), Alloc());
407        C c2(0, Hash(2), Compare(2), Alloc());
408        c2.max_load_factor(2);
409        c1.swap(c2);
410
411        assert(c1.bucket_count() == 0);
412        assert(c1.size() == 0);
413        assert(c1.hash_function() == Hash(2));
414        assert(c1.key_eq() == Compare(2));
415        assert(c1.get_allocator() == Alloc());
416        assert(std::distance(c1.begin(), c1.end()) == c1.size());
417        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
418        assert(c1.max_load_factor() == 2);
419
420        assert(c2.bucket_count() == 0);
421        assert(c2.size() == 0);
422        assert(c2.hash_function() == Hash(1));
423        assert(c2.key_eq() == Compare(1));
424        assert(c2.get_allocator() == Alloc());
425        assert(std::distance(c2.begin(), c2.end()) == c2.size());
426        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
427        assert(c2.max_load_factor() == 1);
428    }
429    {
430        typedef test_hash<std::hash<int> > Hash;
431        typedef test_compare<std::equal_to<int> > Compare;
432        typedef min_allocator<std::pair<const int, std::string> > Alloc;
433        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
434        typedef std::pair<int, std::string> P;
435        P a2[] =
436        {
437            P(10, "ten"),
438            P(20, "twenty"),
439            P(30, "thirty"),
440            P(40, "forty"),
441            P(50, "fifty"),
442            P(60, "sixty"),
443            P(70, "seventy"),
444            P(80, "eighty"),
445        };
446        C c1(0, Hash(1), Compare(1), Alloc());
447        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
448        c2.max_load_factor(2);
449        c1.swap(c2);
450
451        assert(c1.bucket_count() >= 11);
452        assert(c1.size() == 8);
453        assert(c1.find(10)->second == "ten");
454        assert(c1.find(20)->second == "twenty");
455        assert(c1.find(30)->second == "thirty");
456        assert(c1.find(40)->second == "forty");
457        assert(c1.find(50)->second == "fifty");
458        assert(c1.find(60)->second == "sixty");
459        assert(c1.find(70)->second == "seventy");
460        assert(c1.find(80)->second == "eighty");
461        assert(c1.hash_function() == Hash(2));
462        assert(c1.key_eq() == Compare(2));
463        assert(c1.get_allocator() == Alloc());
464        assert(std::distance(c1.begin(), c1.end()) == c1.size());
465        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
466        assert(c1.max_load_factor() == 2);
467
468        assert(c2.bucket_count() == 0);
469        assert(c2.size() == 0);
470        assert(c2.hash_function() == Hash(1));
471        assert(c2.key_eq() == Compare(1));
472        assert(c2.get_allocator() == Alloc());
473        assert(std::distance(c2.begin(), c2.end()) == c2.size());
474        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
475        assert(c2.max_load_factor() == 1);
476    }
477    {
478        typedef test_hash<std::hash<int> > Hash;
479        typedef test_compare<std::equal_to<int> > Compare;
480        typedef min_allocator<std::pair<const int, std::string> > Alloc;
481        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
482        typedef std::pair<int, std::string> P;
483        P a1[] =
484        {
485            P(1, "one"),
486            P(2, "two"),
487            P(3, "three"),
488            P(4, "four"),
489            P(1, "four"),
490            P(2, "four"),
491        };
492        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
493        C c2(0, Hash(2), Compare(2), Alloc());
494        c2.max_load_factor(2);
495        c1.swap(c2);
496
497        assert(c1.bucket_count() == 0);
498        assert(c1.size() == 0);
499        assert(c1.hash_function() == Hash(2));
500        assert(c1.key_eq() == Compare(2));
501        assert(c1.get_allocator() == Alloc());
502        assert(std::distance(c1.begin(), c1.end()) == c1.size());
503        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
504        assert(c1.max_load_factor() == 2);
505
506        assert(c2.bucket_count() >= 7);
507        assert(c2.size() == 6);
508        assert(c2.find(1)->second == "one");
509        assert(next(c2.find(1))->second == "four");
510        assert(c2.find(2)->second == "two");
511        assert(next(c2.find(2))->second == "four");
512        assert(c2.find(3)->second == "three");
513        assert(c2.find(4)->second == "four");
514        assert(c2.hash_function() == Hash(1));
515        assert(c2.key_eq() == Compare(1));
516        assert(c2.get_allocator() == Alloc());
517        assert(std::distance(c2.begin(), c2.end()) == c2.size());
518        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
519        assert(c2.max_load_factor() == 1);
520    }
521    {
522        typedef test_hash<std::hash<int> > Hash;
523        typedef test_compare<std::equal_to<int> > Compare;
524        typedef min_allocator<std::pair<const int, std::string> > Alloc;
525        typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
526        typedef std::pair<int, std::string> P;
527        P a1[] =
528        {
529            P(1, "one"),
530            P(2, "two"),
531            P(3, "three"),
532            P(4, "four"),
533            P(1, "four"),
534            P(2, "four"),
535        };
536        P a2[] =
537        {
538            P(10, "ten"),
539            P(20, "twenty"),
540            P(30, "thirty"),
541            P(40, "forty"),
542            P(50, "fifty"),
543            P(60, "sixty"),
544            P(70, "seventy"),
545            P(80, "eighty"),
546        };
547        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
548        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
549        c2.max_load_factor(2);
550        c1.swap(c2);
551
552        assert(c1.bucket_count() >= 11);
553        assert(c1.size() == 8);
554        assert(c1.find(10)->second == "ten");
555        assert(c1.find(20)->second == "twenty");
556        assert(c1.find(30)->second == "thirty");
557        assert(c1.find(40)->second == "forty");
558        assert(c1.find(50)->second == "fifty");
559        assert(c1.find(60)->second == "sixty");
560        assert(c1.find(70)->second == "seventy");
561        assert(c1.find(80)->second == "eighty");
562        assert(c1.hash_function() == Hash(2));
563        assert(c1.key_eq() == Compare(2));
564        assert(c1.get_allocator() == Alloc());
565        assert(std::distance(c1.begin(), c1.end()) == c1.size());
566        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
567        assert(c1.max_load_factor() == 2);
568
569        assert(c2.bucket_count() >= 7);
570        assert(c2.size() == 6);
571        assert(c2.find(1)->second == "one");
572        assert(next(c2.find(1))->second == "four");
573        assert(c2.find(2)->second == "two");
574        assert(next(c2.find(2))->second == "four");
575        assert(c2.find(3)->second == "three");
576        assert(c2.find(4)->second == "four");
577        assert(c2.hash_function() == Hash(1));
578        assert(c2.key_eq() == Compare(1));
579        assert(c2.get_allocator() == Alloc());
580        assert(std::distance(c2.begin(), c2.end()) == c2.size());
581        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
582        assert(c2.max_load_factor() == 1);
583    }
584#endif
585}
586