swap_non_member.pass.cpp revision b64f8b07c104c6cc986570ac8ee0ed16a9f23976 
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& x, unordered_multiset& y);
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
25int main()
26{
27    {
28        typedef test_hash<std::hash<int> > Hash;
29        typedef test_compare<std::equal_to<int> > Compare;
30        typedef test_allocator<int> Alloc;
31        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
32        typedef int P;
33        C c1(0, Hash(1), Compare(1), Alloc(1));
34        C c2(0, Hash(2), Compare(2), Alloc(2));
35        c2.max_load_factor(2);
36        swap(c1, c2);
37
38        assert(c1.bucket_count() == 0);
39        assert(c1.size() == 0);
40        assert(c1.hash_function() == Hash(2));
41        assert(c1.key_eq() == Compare(2));
42        assert(c1.get_allocator() == Alloc(1));
43        assert(std::distance(c1.begin(), c1.end()) == c1.size());
44        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
45        assert(c1.max_load_factor() == 2);
46
47        assert(c2.bucket_count() == 0);
48        assert(c2.size() == 0);
49        assert(c2.hash_function() == Hash(1));
50        assert(c2.key_eq() == Compare(1));
51        assert(c2.get_allocator() == Alloc(2));
52        assert(std::distance(c2.begin(), c2.end()) == c2.size());
53        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
54        assert(c2.max_load_factor() == 1);
55    }
56    {
57        typedef test_hash<std::hash<int> > Hash;
58        typedef test_compare<std::equal_to<int> > Compare;
59        typedef test_allocator<int> Alloc;
60        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
61        typedef int P;
62        P a2[] =
63        {
64            P(10),
65            P(20),
66            P(30),
67            P(40),
68            P(50),
69            P(60),
70            P(70),
71            P(80)
72        };
73        C c1(0, Hash(1), Compare(1), Alloc(1));
74        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
75        c2.max_load_factor(2);
76        swap(c1, c2);
77
78        assert(c1.bucket_count() >= 11);
79        assert(c1.size() == 8);
80        assert(*c1.find(10) == 10);
81        assert(*c1.find(20) == 20);
82        assert(*c1.find(30) == 30);
83        assert(*c1.find(40) == 40);
84        assert(*c1.find(50) == 50);
85        assert(*c1.find(60) == 60);
86        assert(*c1.find(70) == 70);
87        assert(*c1.find(80) == 80);
88        assert(c1.hash_function() == Hash(2));
89        assert(c1.key_eq() == Compare(2));
90        assert(c1.get_allocator() == Alloc(1));
91        assert(std::distance(c1.begin(), c1.end()) == c1.size());
92        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
93        assert(c1.max_load_factor() == 2);
94
95        assert(c2.bucket_count() == 0);
96        assert(c2.size() == 0);
97        assert(c2.hash_function() == Hash(1));
98        assert(c2.key_eq() == Compare(1));
99        assert(c2.get_allocator() == Alloc(2));
100        assert(std::distance(c2.begin(), c2.end()) == c2.size());
101        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
102        assert(c2.max_load_factor() == 1);
103    }
104    {
105        typedef test_hash<std::hash<int> > Hash;
106        typedef test_compare<std::equal_to<int> > Compare;
107        typedef test_allocator<int> Alloc;
108        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
109        typedef int P;
110        P a1[] =
111        {
112            P(1),
113            P(2),
114            P(3),
115            P(4),
116            P(1),
117            P(2)
118        };
119        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
120        C c2(0, Hash(2), Compare(2), Alloc(2));
121        c2.max_load_factor(2);
122        swap(c1, c2);
123
124        assert(c1.bucket_count() == 0);
125        assert(c1.size() == 0);
126        assert(c1.hash_function() == Hash(2));
127        assert(c1.key_eq() == Compare(2));
128        assert(c1.get_allocator() == Alloc(1));
129        assert(std::distance(c1.begin(), c1.end()) == c1.size());
130        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
131        assert(c1.max_load_factor() == 2);
132
133        assert(c2.bucket_count() >= 7);
134        assert(c2.size() == 6);
135        assert(c2.count(1) == 2);
136        assert(c2.count(2) == 2);
137        assert(c2.count(3) == 1);
138        assert(c2.count(4) == 1);
139        assert(c2.hash_function() == Hash(1));
140        assert(c2.key_eq() == Compare(1));
141        assert(c2.get_allocator() == Alloc(2));
142        assert(std::distance(c2.begin(), c2.end()) == c2.size());
143        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
144        assert(c2.max_load_factor() == 1);
145    }
146    {
147        typedef test_hash<std::hash<int> > Hash;
148        typedef test_compare<std::equal_to<int> > Compare;
149        typedef test_allocator<int> Alloc;
150        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
151        typedef int P;
152        P a1[] =
153        {
154            P(1),
155            P(2),
156            P(3),
157            P(4),
158            P(1),
159            P(2)
160        };
161        P a2[] =
162        {
163            P(10),
164            P(20),
165            P(30),
166            P(40),
167            P(50),
168            P(60),
169            P(70),
170            P(80)
171        };
172        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
173        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
174        c2.max_load_factor(2);
175        swap(c1, c2);
176
177        assert(c1.bucket_count() >= 11);
178        assert(c1.size() == 8);
179        assert(*c1.find(10) == 10);
180        assert(*c1.find(20) == 20);
181        assert(*c1.find(30) == 30);
182        assert(*c1.find(40) == 40);
183        assert(*c1.find(50) == 50);
184        assert(*c1.find(60) == 60);
185        assert(*c1.find(70) == 70);
186        assert(*c1.find(80) == 80);
187        assert(c1.hash_function() == Hash(2));
188        assert(c1.key_eq() == Compare(2));
189        assert(c1.get_allocator() == Alloc(1));
190        assert(std::distance(c1.begin(), c1.end()) == c1.size());
191        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
192        assert(c1.max_load_factor() == 2);
193
194        assert(c2.bucket_count() >= 7);
195        assert(c2.size() == 6);
196        assert(c2.count(1) == 2);
197        assert(c2.count(2) == 2);
198        assert(c2.count(3) == 1);
199        assert(c2.count(4) == 1);
200        assert(c2.hash_function() == Hash(1));
201        assert(c2.key_eq() == Compare(1));
202        assert(c2.get_allocator() == Alloc(2));
203        assert(std::distance(c2.begin(), c2.end()) == c2.size());
204        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
205        assert(c2.max_load_factor() == 1);
206    }
207
208    {
209        typedef test_hash<std::hash<int> > Hash;
210        typedef test_compare<std::equal_to<int> > Compare;
211        typedef other_allocator<int> Alloc;
212        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
213        typedef int P;
214        C c1(0, Hash(1), Compare(1), Alloc(1));
215        C c2(0, Hash(2), Compare(2), Alloc(2));
216        c2.max_load_factor(2);
217        swap(c1, c2);
218
219        assert(c1.bucket_count() == 0);
220        assert(c1.size() == 0);
221        assert(c1.hash_function() == Hash(2));
222        assert(c1.key_eq() == Compare(2));
223        assert(c1.get_allocator() == Alloc(2));
224        assert(std::distance(c1.begin(), c1.end()) == c1.size());
225        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
226        assert(c1.max_load_factor() == 2);
227
228        assert(c2.bucket_count() == 0);
229        assert(c2.size() == 0);
230        assert(c2.hash_function() == Hash(1));
231        assert(c2.key_eq() == Compare(1));
232        assert(c2.get_allocator() == Alloc(1));
233        assert(std::distance(c2.begin(), c2.end()) == c2.size());
234        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
235        assert(c2.max_load_factor() == 1);
236    }
237    {
238        typedef test_hash<std::hash<int> > Hash;
239        typedef test_compare<std::equal_to<int> > Compare;
240        typedef other_allocator<int> Alloc;
241        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
242        typedef int P;
243        P a2[] =
244        {
245            P(10),
246            P(20),
247            P(30),
248            P(40),
249            P(50),
250            P(60),
251            P(70),
252            P(80)
253        };
254        C c1(0, Hash(1), Compare(1), Alloc(1));
255        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
256        c2.max_load_factor(2);
257        swap(c1, c2);
258
259        assert(c1.bucket_count() >= 11);
260        assert(c1.size() == 8);
261        assert(*c1.find(10) == 10);
262        assert(*c1.find(20) == 20);
263        assert(*c1.find(30) == 30);
264        assert(*c1.find(40) == 40);
265        assert(*c1.find(50) == 50);
266        assert(*c1.find(60) == 60);
267        assert(*c1.find(70) == 70);
268        assert(*c1.find(80) == 80);
269        assert(c1.hash_function() == Hash(2));
270        assert(c1.key_eq() == Compare(2));
271        assert(c1.get_allocator() == Alloc(2));
272        assert(std::distance(c1.begin(), c1.end()) == c1.size());
273        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
274        assert(c1.max_load_factor() == 2);
275
276        assert(c2.bucket_count() == 0);
277        assert(c2.size() == 0);
278        assert(c2.hash_function() == Hash(1));
279        assert(c2.key_eq() == Compare(1));
280        assert(c2.get_allocator() == Alloc(1));
281        assert(std::distance(c2.begin(), c2.end()) == c2.size());
282        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
283        assert(c2.max_load_factor() == 1);
284    }
285    {
286        typedef test_hash<std::hash<int> > Hash;
287        typedef test_compare<std::equal_to<int> > Compare;
288        typedef other_allocator<int> Alloc;
289        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
290        typedef int P;
291        P a1[] =
292        {
293            P(1),
294            P(2),
295            P(3),
296            P(4),
297            P(1),
298            P(2)
299        };
300        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
301        C c2(0, Hash(2), Compare(2), Alloc(2));
302        c2.max_load_factor(2);
303        swap(c1, c2);
304
305        assert(c1.bucket_count() == 0);
306        assert(c1.size() == 0);
307        assert(c1.hash_function() == Hash(2));
308        assert(c1.key_eq() == Compare(2));
309        assert(c1.get_allocator() == Alloc(2));
310        assert(std::distance(c1.begin(), c1.end()) == c1.size());
311        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
312        assert(c1.max_load_factor() == 2);
313
314        assert(c2.bucket_count() >= 7);
315        assert(c2.size() == 6);
316        assert(c2.count(1) == 2);
317        assert(c2.count(2) == 2);
318        assert(c2.count(3) == 1);
319        assert(c2.count(4) == 1);
320        assert(c2.hash_function() == Hash(1));
321        assert(c2.key_eq() == Compare(1));
322        assert(c2.get_allocator() == Alloc(1));
323        assert(std::distance(c2.begin(), c2.end()) == c2.size());
324        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
325        assert(c2.max_load_factor() == 1);
326    }
327    {
328        typedef test_hash<std::hash<int> > Hash;
329        typedef test_compare<std::equal_to<int> > Compare;
330        typedef other_allocator<int> Alloc;
331        typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
332        typedef int P;
333        P a1[] =
334        {
335            P(1),
336            P(2),
337            P(3),
338            P(4),
339            P(1),
340            P(2)
341        };
342        P a2[] =
343        {
344            P(10),
345            P(20),
346            P(30),
347            P(40),
348            P(50),
349            P(60),
350            P(70),
351            P(80)
352        };
353        C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
354        C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
355        c2.max_load_factor(2);
356        swap(c1, c2);
357
358        assert(c1.bucket_count() >= 11);
359        assert(c1.size() == 8);
360        assert(*c1.find(10) == 10);
361        assert(*c1.find(20) == 20);
362        assert(*c1.find(30) == 30);
363        assert(*c1.find(40) == 40);
364        assert(*c1.find(50) == 50);
365        assert(*c1.find(60) == 60);
366        assert(*c1.find(70) == 70);
367        assert(*c1.find(80) == 80);
368        assert(c1.hash_function() == Hash(2));
369        assert(c1.key_eq() == Compare(2));
370        assert(c1.get_allocator() == Alloc(2));
371        assert(std::distance(c1.begin(), c1.end()) == c1.size());
372        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
373        assert(c1.max_load_factor() == 2);
374
375        assert(c2.bucket_count() >= 7);
376        assert(c2.size() == 6);
377        assert(c2.count(1) == 2);
378        assert(c2.count(2) == 2);
379        assert(c2.count(3) == 1);
380        assert(c2.count(4) == 1);
381        assert(c2.hash_function() == Hash(1));
382        assert(c2.key_eq() == Compare(1));
383        assert(c2.get_allocator() == Alloc(1));
384        assert(std::distance(c2.begin(), c2.end()) == c2.size());
385        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
386        assert(c2.max_load_factor() == 1);
387    }
388}
389