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
main()29 int 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