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_set>
11
12 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
13 // class Alloc = allocator<Value>>
14 // class unordered_multiset
15
16 // void swap(unordered_multiset& __u);
17
18 #include <unordered_set>
19 #include <cassert>
20
21 #include "../../test_compare.h"
22 #include "../../test_hash.h"
23 #include "test_allocator.h"
24 #include "min_allocator.h"
25
main()26 int main()
27 {
28 {
29 typedef test_hash<std::hash<int> > Hash;
30 typedef test_compare<std::equal_to<int> > Compare;
31 typedef test_allocator<int> Alloc;
32 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
33 typedef int P;
34 C c1(0, Hash(1), Compare(1), Alloc(1));
35 C c2(0, Hash(2), Compare(2), Alloc(2));
36 c2.max_load_factor(2);
37 c1.swap(c2);
38
39 assert(c1.bucket_count() == 0);
40 assert(c1.size() == 0);
41 assert(c1.hash_function() == Hash(2));
42 assert(c1.key_eq() == Compare(2));
43 assert(c1.get_allocator() == Alloc(1));
44 assert(std::distance(c1.begin(), c1.end()) == c1.size());
45 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
46 assert(c1.max_load_factor() == 2);
47
48 assert(c2.bucket_count() == 0);
49 assert(c2.size() == 0);
50 assert(c2.hash_function() == Hash(1));
51 assert(c2.key_eq() == Compare(1));
52 assert(c2.get_allocator() == Alloc(2));
53 assert(std::distance(c2.begin(), c2.end()) == c2.size());
54 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
55 assert(c2.max_load_factor() == 1);
56 }
57 {
58 typedef test_hash<std::hash<int> > Hash;
59 typedef test_compare<std::equal_to<int> > Compare;
60 typedef test_allocator<int> Alloc;
61 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
62 typedef int P;
63 P a2[] =
64 {
65 P(10),
66 P(20),
67 P(30),
68 P(40),
69 P(50),
70 P(60),
71 P(70),
72 P(80)
73 };
74 C c1(0, Hash(1), Compare(1), Alloc(1));
75 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
76 c2.max_load_factor(2);
77 c1.swap(c2);
78
79 assert(c1.bucket_count() >= 11);
80 assert(c1.size() == 8);
81 assert(*c1.find(10) == 10);
82 assert(*c1.find(20) == 20);
83 assert(*c1.find(30) == 30);
84 assert(*c1.find(40) == 40);
85 assert(*c1.find(50) == 50);
86 assert(*c1.find(60) == 60);
87 assert(*c1.find(70) == 70);
88 assert(*c1.find(80) == 80);
89 assert(c1.hash_function() == Hash(2));
90 assert(c1.key_eq() == Compare(2));
91 assert(c1.get_allocator() == Alloc(1));
92 assert(std::distance(c1.begin(), c1.end()) == c1.size());
93 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
94 assert(c1.max_load_factor() == 2);
95
96 assert(c2.bucket_count() == 0);
97 assert(c2.size() == 0);
98 assert(c2.hash_function() == Hash(1));
99 assert(c2.key_eq() == Compare(1));
100 assert(c2.get_allocator() == Alloc(2));
101 assert(std::distance(c2.begin(), c2.end()) == c2.size());
102 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
103 assert(c2.max_load_factor() == 1);
104 }
105 {
106 typedef test_hash<std::hash<int> > Hash;
107 typedef test_compare<std::equal_to<int> > Compare;
108 typedef test_allocator<int> Alloc;
109 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
110 typedef int P;
111 P a1[] =
112 {
113 P(1),
114 P(2),
115 P(3),
116 P(4),
117 P(1),
118 P(2)
119 };
120 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
121 C c2(0, Hash(2), Compare(2), Alloc(2));
122 c2.max_load_factor(2);
123 c1.swap(c2);
124
125 assert(c1.bucket_count() == 0);
126 assert(c1.size() == 0);
127 assert(c1.hash_function() == Hash(2));
128 assert(c1.key_eq() == Compare(2));
129 assert(c1.get_allocator() == Alloc(1));
130 assert(std::distance(c1.begin(), c1.end()) == c1.size());
131 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
132 assert(c1.max_load_factor() == 2);
133
134 assert(c2.bucket_count() >= 7);
135 assert(c2.size() == 6);
136 assert(c2.count(1) == 2);
137 assert(c2.count(2) == 2);
138 assert(c2.count(3) == 1);
139 assert(c2.count(4) == 1);
140 assert(c2.hash_function() == Hash(1));
141 assert(c2.key_eq() == Compare(1));
142 assert(c2.get_allocator() == Alloc(2));
143 assert(std::distance(c2.begin(), c2.end()) == c2.size());
144 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
145 assert(c2.max_load_factor() == 1);
146 }
147 {
148 typedef test_hash<std::hash<int> > Hash;
149 typedef test_compare<std::equal_to<int> > Compare;
150 typedef test_allocator<int> Alloc;
151 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
152 typedef int P;
153 P a1[] =
154 {
155 P(1),
156 P(2),
157 P(3),
158 P(4),
159 P(1),
160 P(2)
161 };
162 P a2[] =
163 {
164 P(10),
165 P(20),
166 P(30),
167 P(40),
168 P(50),
169 P(60),
170 P(70),
171 P(80)
172 };
173 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
174 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
175 c2.max_load_factor(2);
176 c1.swap(c2);
177
178 assert(c1.bucket_count() >= 11);
179 assert(c1.size() == 8);
180 assert(*c1.find(10) == 10);
181 assert(*c1.find(20) == 20);
182 assert(*c1.find(30) == 30);
183 assert(*c1.find(40) == 40);
184 assert(*c1.find(50) == 50);
185 assert(*c1.find(60) == 60);
186 assert(*c1.find(70) == 70);
187 assert(*c1.find(80) == 80);
188 assert(c1.hash_function() == Hash(2));
189 assert(c1.key_eq() == Compare(2));
190 assert(c1.get_allocator() == Alloc(1));
191 assert(std::distance(c1.begin(), c1.end()) == c1.size());
192 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
193 assert(c1.max_load_factor() == 2);
194
195 assert(c2.bucket_count() >= 7);
196 assert(c2.size() == 6);
197 assert(c2.count(1) == 2);
198 assert(c2.count(2) == 2);
199 assert(c2.count(3) == 1);
200 assert(c2.count(4) == 1);
201 assert(c2.hash_function() == Hash(1));
202 assert(c2.key_eq() == Compare(1));
203 assert(c2.get_allocator() == Alloc(2));
204 assert(std::distance(c2.begin(), c2.end()) == c2.size());
205 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
206 assert(c2.max_load_factor() == 1);
207 }
208
209 {
210 typedef test_hash<std::hash<int> > Hash;
211 typedef test_compare<std::equal_to<int> > Compare;
212 typedef other_allocator<int> Alloc;
213 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
214 typedef int P;
215 C c1(0, Hash(1), Compare(1), Alloc(1));
216 C c2(0, Hash(2), Compare(2), Alloc(2));
217 c2.max_load_factor(2);
218 c1.swap(c2);
219
220 assert(c1.bucket_count() == 0);
221 assert(c1.size() == 0);
222 assert(c1.hash_function() == Hash(2));
223 assert(c1.key_eq() == Compare(2));
224 assert(c1.get_allocator() == Alloc(2));
225 assert(std::distance(c1.begin(), c1.end()) == c1.size());
226 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
227 assert(c1.max_load_factor() == 2);
228
229 assert(c2.bucket_count() == 0);
230 assert(c2.size() == 0);
231 assert(c2.hash_function() == Hash(1));
232 assert(c2.key_eq() == Compare(1));
233 assert(c2.get_allocator() == Alloc(1));
234 assert(std::distance(c2.begin(), c2.end()) == c2.size());
235 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
236 assert(c2.max_load_factor() == 1);
237 }
238 {
239 typedef test_hash<std::hash<int> > Hash;
240 typedef test_compare<std::equal_to<int> > Compare;
241 typedef other_allocator<int> Alloc;
242 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
243 typedef int P;
244 P a2[] =
245 {
246 P(10),
247 P(20),
248 P(30),
249 P(40),
250 P(50),
251 P(60),
252 P(70),
253 P(80)
254 };
255 C c1(0, Hash(1), Compare(1), Alloc(1));
256 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
257 c2.max_load_factor(2);
258 c1.swap(c2);
259
260 assert(c1.bucket_count() >= 11);
261 assert(c1.size() == 8);
262 assert(*c1.find(10) == 10);
263 assert(*c1.find(20) == 20);
264 assert(*c1.find(30) == 30);
265 assert(*c1.find(40) == 40);
266 assert(*c1.find(50) == 50);
267 assert(*c1.find(60) == 60);
268 assert(*c1.find(70) == 70);
269 assert(*c1.find(80) == 80);
270 assert(c1.hash_function() == Hash(2));
271 assert(c1.key_eq() == Compare(2));
272 assert(c1.get_allocator() == Alloc(2));
273 assert(std::distance(c1.begin(), c1.end()) == c1.size());
274 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
275 assert(c1.max_load_factor() == 2);
276
277 assert(c2.bucket_count() == 0);
278 assert(c2.size() == 0);
279 assert(c2.hash_function() == Hash(1));
280 assert(c2.key_eq() == Compare(1));
281 assert(c2.get_allocator() == Alloc(1));
282 assert(std::distance(c2.begin(), c2.end()) == c2.size());
283 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
284 assert(c2.max_load_factor() == 1);
285 }
286 {
287 typedef test_hash<std::hash<int> > Hash;
288 typedef test_compare<std::equal_to<int> > Compare;
289 typedef other_allocator<int> Alloc;
290 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
291 typedef int P;
292 P a1[] =
293 {
294 P(1),
295 P(2),
296 P(3),
297 P(4),
298 P(1),
299 P(2)
300 };
301 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
302 C c2(0, Hash(2), Compare(2), Alloc(2));
303 c2.max_load_factor(2);
304 c1.swap(c2);
305
306 assert(c1.bucket_count() == 0);
307 assert(c1.size() == 0);
308 assert(c1.hash_function() == Hash(2));
309 assert(c1.key_eq() == Compare(2));
310 assert(c1.get_allocator() == Alloc(2));
311 assert(std::distance(c1.begin(), c1.end()) == c1.size());
312 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
313 assert(c1.max_load_factor() == 2);
314
315 assert(c2.bucket_count() >= 7);
316 assert(c2.size() == 6);
317 assert(c2.count(1) == 2);
318 assert(c2.count(2) == 2);
319 assert(c2.count(3) == 1);
320 assert(c2.count(4) == 1);
321 assert(c2.hash_function() == Hash(1));
322 assert(c2.key_eq() == Compare(1));
323 assert(c2.get_allocator() == Alloc(1));
324 assert(std::distance(c2.begin(), c2.end()) == c2.size());
325 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
326 assert(c2.max_load_factor() == 1);
327 }
328 {
329 typedef test_hash<std::hash<int> > Hash;
330 typedef test_compare<std::equal_to<int> > Compare;
331 typedef other_allocator<int> Alloc;
332 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
333 typedef int P;
334 P a1[] =
335 {
336 P(1),
337 P(2),
338 P(3),
339 P(4),
340 P(1),
341 P(2)
342 };
343 P a2[] =
344 {
345 P(10),
346 P(20),
347 P(30),
348 P(40),
349 P(50),
350 P(60),
351 P(70),
352 P(80)
353 };
354 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
355 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
356 c2.max_load_factor(2);
357 c1.swap(c2);
358
359 assert(c1.bucket_count() >= 11);
360 assert(c1.size() == 8);
361 assert(*c1.find(10) == 10);
362 assert(*c1.find(20) == 20);
363 assert(*c1.find(30) == 30);
364 assert(*c1.find(40) == 40);
365 assert(*c1.find(50) == 50);
366 assert(*c1.find(60) == 60);
367 assert(*c1.find(70) == 70);
368 assert(*c1.find(80) == 80);
369 assert(c1.hash_function() == Hash(2));
370 assert(c1.key_eq() == Compare(2));
371 assert(c1.get_allocator() == Alloc(2));
372 assert(std::distance(c1.begin(), c1.end()) == c1.size());
373 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
374 assert(c1.max_load_factor() == 2);
375
376 assert(c2.bucket_count() >= 7);
377 assert(c2.size() == 6);
378 assert(c2.count(1) == 2);
379 assert(c2.count(2) == 2);
380 assert(c2.count(3) == 1);
381 assert(c2.count(4) == 1);
382 assert(c2.hash_function() == Hash(1));
383 assert(c2.key_eq() == Compare(1));
384 assert(c2.get_allocator() == Alloc(1));
385 assert(std::distance(c2.begin(), c2.end()) == c2.size());
386 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
387 assert(c2.max_load_factor() == 1);
388 }
389 #if __cplusplus >= 201103L
390 {
391 typedef test_hash<std::hash<int> > Hash;
392 typedef test_compare<std::equal_to<int> > Compare;
393 typedef min_allocator<int> Alloc;
394 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
395 typedef int P;
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 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(std::distance(c1.begin(), c1.end()) == c1.size());
407 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
408 assert(c1.max_load_factor() == 2);
409
410 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(std::distance(c2.begin(), c2.end()) == c2.size());
416 assert(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<int> Alloc;
423 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
424 typedef int P;
425 P a2[] =
426 {
427 P(10),
428 P(20),
429 P(30),
430 P(40),
431 P(50),
432 P(60),
433 P(70),
434 P(80)
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() >= 11);
442 assert(c1.size() == 8);
443 assert(*c1.find(10) == 10);
444 assert(*c1.find(20) == 20);
445 assert(*c1.find(30) == 30);
446 assert(*c1.find(40) == 40);
447 assert(*c1.find(50) == 50);
448 assert(*c1.find(60) == 60);
449 assert(*c1.find(70) == 70);
450 assert(*c1.find(80) == 80);
451 assert(c1.hash_function() == Hash(2));
452 assert(c1.key_eq() == Compare(2));
453 assert(c1.get_allocator() == Alloc());
454 assert(std::distance(c1.begin(), c1.end()) == c1.size());
455 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
456 assert(c1.max_load_factor() == 2);
457
458 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(std::distance(c2.begin(), c2.end()) == c2.size());
464 assert(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<int> Alloc;
471 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
472 typedef int P;
473 P a1[] =
474 {
475 P(1),
476 P(2),
477 P(3),
478 P(4),
479 P(1),
480 P(2)
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 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(std::distance(c1.begin(), c1.end()) == c1.size());
493 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
494 assert(c1.max_load_factor() == 2);
495
496 assert(c2.bucket_count() >= 7);
497 assert(c2.size() == 6);
498 assert(c2.count(1) == 2);
499 assert(c2.count(2) == 2);
500 assert(c2.count(3) == 1);
501 assert(c2.count(4) == 1);
502 assert(c2.hash_function() == Hash(1));
503 assert(c2.key_eq() == Compare(1));
504 assert(c2.get_allocator() == Alloc());
505 assert(std::distance(c2.begin(), c2.end()) == c2.size());
506 assert(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<int> Alloc;
513 typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
514 typedef int P;
515 P a1[] =
516 {
517 P(1),
518 P(2),
519 P(3),
520 P(4),
521 P(1),
522 P(2)
523 };
524 P a2[] =
525 {
526 P(10),
527 P(20),
528 P(30),
529 P(40),
530 P(50),
531 P(60),
532 P(70),
533 P(80)
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() >= 11);
541 assert(c1.size() == 8);
542 assert(*c1.find(10) == 10);
543 assert(*c1.find(20) == 20);
544 assert(*c1.find(30) == 30);
545 assert(*c1.find(40) == 40);
546 assert(*c1.find(50) == 50);
547 assert(*c1.find(60) == 60);
548 assert(*c1.find(70) == 70);
549 assert(*c1.find(80) == 80);
550 assert(c1.hash_function() == Hash(2));
551 assert(c1.key_eq() == Compare(2));
552 assert(c1.get_allocator() == Alloc());
553 assert(std::distance(c1.begin(), c1.end()) == c1.size());
554 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
555 assert(c1.max_load_factor() == 2);
556
557 assert(c2.bucket_count() >= 7);
558 assert(c2.size() == 6);
559 assert(c2.count(1) == 2);
560 assert(c2.count(2) == 2);
561 assert(c2.count(3) == 1);
562 assert(c2.count(4) == 1);
563 assert(c2.hash_function() == Hash(1));
564 assert(c2.key_eq() == Compare(1));
565 assert(c2.get_allocator() == Alloc());
566 assert(std::distance(c2.begin(), c2.end()) == c2.size());
567 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
568 assert(c2.max_load_factor() == 1);
569 }
570 #endif
571 }
572