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
main()28 int 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, "fourty"),
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 == "fourty");
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, "fourty"),
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 == "fourty");
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, "fourty"),
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 == "fourty");
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, "fourty"),
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 == "fourty");
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, "fourty"),
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 == "fourty");
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, "fourty"),
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 == "fourty");
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