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