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