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 // local_iterator       begin (size_type n);
17 // local_iterator       end   (size_type n);
18 // const_local_iterator begin (size_type n) const;
19 // const_local_iterator end   (size_type n) const;
20 // const_local_iterator cbegin(size_type n) const;
21 // const_local_iterator cend  (size_type n) const;
22 
23 #include <unordered_set>
24 #include <cassert>
25 
26 #include "../../min_allocator.h"
27 
28 int main()
29 {
30     {
31         typedef std::unordered_multiset<int> C;
32         typedef int P;
33         typedef C::local_iterator I;
34         P a[] =
35         {
36             P(1),
37             P(2),
38             P(3),
39             P(4),
40             P(1),
41             P(2)
42         };
43         C c(a, a + sizeof(a)/sizeof(a[0]));
44         assert(c.bucket_count() >= 7);
45         C::size_type b = c.bucket(0);
46         I i = c.begin(b);
47         I j = c.end(b);
48         assert(std::distance(i, j) == 0);
49 
50         b = c.bucket(1);
51         i = c.begin(b);
52         j = c.end(b);
53         assert(std::distance(i, j) == 2);
54         assert(*i == 1);
55         ++i;
56         assert(*i == 1);
57 
58         b = c.bucket(2);
59         i = c.begin(b);
60         j = c.end(b);
61         assert(std::distance(i, j) == 2);
62         assert(*i == 2);
63         ++i;
64         assert(*i == 2);
65 
66         b = c.bucket(3);
67         i = c.begin(b);
68         j = c.end(b);
69         assert(std::distance(i, j) == 1);
70         assert(*i == 3);
71 
72         b = c.bucket(4);
73         i = c.begin(b);
74         j = c.end(b);
75         assert(std::distance(i, j) == 1);
76         assert(*i == 4);
77 
78         b = c.bucket(5);
79         i = c.begin(b);
80         j = c.end(b);
81         assert(std::distance(i, j) == 0);
82 
83         b = c.bucket(6);
84         i = c.begin(b);
85         j = c.end(b);
86         assert(std::distance(i, j) == 0);
87     }
88     {
89         typedef std::unordered_multiset<int> C;
90         typedef int P;
91         typedef C::const_local_iterator I;
92         P a[] =
93         {
94             P(1),
95             P(2),
96             P(3),
97             P(4),
98             P(1),
99             P(2)
100         };
101         const C c(a, a + sizeof(a)/sizeof(a[0]));
102         assert(c.bucket_count() >= 7);
103         C::size_type b = c.bucket(0);
104         I i = c.begin(b);
105         I j = c.end(b);
106         assert(std::distance(i, j) == 0);
107 
108         b = c.bucket(1);
109         i = c.begin(b);
110         j = c.end(b);
111         assert(std::distance(i, j) == 2);
112         assert(*i == 1);
113         ++i;
114         assert(*i == 1);
115 
116         b = c.bucket(2);
117         i = c.begin(b);
118         j = c.end(b);
119         assert(std::distance(i, j) == 2);
120         assert(*i == 2);
121         ++i;
122         assert(*i == 2);
123 
124         b = c.bucket(3);
125         i = c.begin(b);
126         j = c.end(b);
127         assert(std::distance(i, j) == 1);
128         assert(*i == 3);
129 
130         b = c.bucket(4);
131         i = c.begin(b);
132         j = c.end(b);
133         assert(std::distance(i, j) == 1);
134         assert(*i == 4);
135 
136         b = c.bucket(5);
137         i = c.begin(b);
138         j = c.end(b);
139         assert(std::distance(i, j) == 0);
140 
141         b = c.bucket(6);
142         i = c.begin(b);
143         j = c.end(b);
144         assert(std::distance(i, j) == 0);
145     }
146     {
147         typedef std::unordered_multiset<int> C;
148         typedef int P;
149         typedef C::const_local_iterator I;
150         P a[] =
151         {
152             P(1),
153             P(2),
154             P(3),
155             P(4),
156             P(1),
157             P(2)
158         };
159         C c(a, a + sizeof(a)/sizeof(a[0]));
160         assert(c.bucket_count() >= 7);
161         C::size_type b = c.bucket(0);
162         I i = c.cbegin(b);
163         I j = c.cend(b);
164         assert(std::distance(i, j) == 0);
165 
166         b = c.bucket(1);
167         i = c.cbegin(b);
168         j = c.cend(b);
169         assert(std::distance(i, j) == 2);
170         assert(*i == 1);
171         ++i;
172         assert(*i == 1);
173 
174         b = c.bucket(2);
175         i = c.cbegin(b);
176         j = c.cend(b);
177         assert(std::distance(i, j) == 2);
178         assert(*i == 2);
179         ++i;
180         assert(*i == 2);
181 
182         b = c.bucket(3);
183         i = c.cbegin(b);
184         j = c.cend(b);
185         assert(std::distance(i, j) == 1);
186         assert(*i == 3);
187 
188         b = c.bucket(4);
189         i = c.cbegin(b);
190         j = c.cend(b);
191         assert(std::distance(i, j) == 1);
192         assert(*i == 4);
193 
194         b = c.bucket(5);
195         i = c.cbegin(b);
196         j = c.cend(b);
197         assert(std::distance(i, j) == 0);
198 
199         b = c.bucket(6);
200         i = c.cbegin(b);
201         j = c.cend(b);
202         assert(std::distance(i, j) == 0);
203     }
204     {
205         typedef std::unordered_multiset<int> C;
206         typedef int P;
207         typedef C::const_local_iterator I;
208         P a[] =
209         {
210             P(1),
211             P(2),
212             P(3),
213             P(4),
214             P(1),
215             P(2)
216         };
217         const C c(a, a + sizeof(a)/sizeof(a[0]));
218         assert(c.bucket_count() >= 7);
219         C::size_type b = c.bucket(0);
220         I i = c.cbegin(b);
221         I j = c.cend(b);
222         assert(std::distance(i, j) == 0);
223 
224         b = c.bucket(1);
225         i = c.cbegin(b);
226         j = c.cend(b);
227         assert(std::distance(i, j) == 2);
228         assert(*i == 1);
229         ++i;
230         assert(*i == 1);
231 
232         b = c.bucket(2);
233         i = c.cbegin(b);
234         j = c.cend(b);
235         assert(std::distance(i, j) == 2);
236         assert(*i == 2);
237         ++i;
238         assert(*i == 2);
239 
240         b = c.bucket(3);
241         i = c.cbegin(b);
242         j = c.cend(b);
243         assert(std::distance(i, j) == 1);
244         assert(*i == 3);
245 
246         b = c.bucket(4);
247         i = c.cbegin(b);
248         j = c.cend(b);
249         assert(std::distance(i, j) == 1);
250         assert(*i == 4);
251 
252         b = c.bucket(5);
253         i = c.cbegin(b);
254         j = c.cend(b);
255         assert(std::distance(i, j) == 0);
256 
257         b = c.bucket(6);
258         i = c.cbegin(b);
259         j = c.cend(b);
260         assert(std::distance(i, j) == 0);
261     }
262 #if __cplusplus >= 201103L
263     {
264         typedef std::unordered_multiset<int, std::hash<int>,
265                                       std::equal_to<int>, min_allocator<int>> C;
266         typedef int P;
267         typedef C::local_iterator I;
268         P a[] =
269         {
270             P(1),
271             P(2),
272             P(3),
273             P(4),
274             P(1),
275             P(2)
276         };
277         C c(a, a + sizeof(a)/sizeof(a[0]));
278         assert(c.bucket_count() >= 7);
279         C::size_type b = c.bucket(0);
280         I i = c.begin(b);
281         I j = c.end(b);
282         assert(std::distance(i, j) == 0);
283 
284         b = c.bucket(1);
285         i = c.begin(b);
286         j = c.end(b);
287         assert(std::distance(i, j) == 2);
288         assert(*i == 1);
289         ++i;
290         assert(*i == 1);
291 
292         b = c.bucket(2);
293         i = c.begin(b);
294         j = c.end(b);
295         assert(std::distance(i, j) == 2);
296         assert(*i == 2);
297         ++i;
298         assert(*i == 2);
299 
300         b = c.bucket(3);
301         i = c.begin(b);
302         j = c.end(b);
303         assert(std::distance(i, j) == 1);
304         assert(*i == 3);
305 
306         b = c.bucket(4);
307         i = c.begin(b);
308         j = c.end(b);
309         assert(std::distance(i, j) == 1);
310         assert(*i == 4);
311 
312         b = c.bucket(5);
313         i = c.begin(b);
314         j = c.end(b);
315         assert(std::distance(i, j) == 0);
316 
317         b = c.bucket(6);
318         i = c.begin(b);
319         j = c.end(b);
320         assert(std::distance(i, j) == 0);
321     }
322     {
323         typedef std::unordered_multiset<int, std::hash<int>,
324                                       std::equal_to<int>, min_allocator<int>> C;
325         typedef int P;
326         typedef C::const_local_iterator I;
327         P a[] =
328         {
329             P(1),
330             P(2),
331             P(3),
332             P(4),
333             P(1),
334             P(2)
335         };
336         const C c(a, a + sizeof(a)/sizeof(a[0]));
337         assert(c.bucket_count() >= 7);
338         C::size_type b = c.bucket(0);
339         I i = c.begin(b);
340         I j = c.end(b);
341         assert(std::distance(i, j) == 0);
342 
343         b = c.bucket(1);
344         i = c.begin(b);
345         j = c.end(b);
346         assert(std::distance(i, j) == 2);
347         assert(*i == 1);
348         ++i;
349         assert(*i == 1);
350 
351         b = c.bucket(2);
352         i = c.begin(b);
353         j = c.end(b);
354         assert(std::distance(i, j) == 2);
355         assert(*i == 2);
356         ++i;
357         assert(*i == 2);
358 
359         b = c.bucket(3);
360         i = c.begin(b);
361         j = c.end(b);
362         assert(std::distance(i, j) == 1);
363         assert(*i == 3);
364 
365         b = c.bucket(4);
366         i = c.begin(b);
367         j = c.end(b);
368         assert(std::distance(i, j) == 1);
369         assert(*i == 4);
370 
371         b = c.bucket(5);
372         i = c.begin(b);
373         j = c.end(b);
374         assert(std::distance(i, j) == 0);
375 
376         b = c.bucket(6);
377         i = c.begin(b);
378         j = c.end(b);
379         assert(std::distance(i, j) == 0);
380     }
381     {
382         typedef std::unordered_multiset<int, std::hash<int>,
383                                       std::equal_to<int>, min_allocator<int>> C;
384         typedef int P;
385         typedef C::const_local_iterator I;
386         P a[] =
387         {
388             P(1),
389             P(2),
390             P(3),
391             P(4),
392             P(1),
393             P(2)
394         };
395         C c(a, a + sizeof(a)/sizeof(a[0]));
396         assert(c.bucket_count() >= 7);
397         C::size_type b = c.bucket(0);
398         I i = c.cbegin(b);
399         I j = c.cend(b);
400         assert(std::distance(i, j) == 0);
401 
402         b = c.bucket(1);
403         i = c.cbegin(b);
404         j = c.cend(b);
405         assert(std::distance(i, j) == 2);
406         assert(*i == 1);
407         ++i;
408         assert(*i == 1);
409 
410         b = c.bucket(2);
411         i = c.cbegin(b);
412         j = c.cend(b);
413         assert(std::distance(i, j) == 2);
414         assert(*i == 2);
415         ++i;
416         assert(*i == 2);
417 
418         b = c.bucket(3);
419         i = c.cbegin(b);
420         j = c.cend(b);
421         assert(std::distance(i, j) == 1);
422         assert(*i == 3);
423 
424         b = c.bucket(4);
425         i = c.cbegin(b);
426         j = c.cend(b);
427         assert(std::distance(i, j) == 1);
428         assert(*i == 4);
429 
430         b = c.bucket(5);
431         i = c.cbegin(b);
432         j = c.cend(b);
433         assert(std::distance(i, j) == 0);
434 
435         b = c.bucket(6);
436         i = c.cbegin(b);
437         j = c.cend(b);
438         assert(std::distance(i, j) == 0);
439     }
440     {
441         typedef std::unordered_multiset<int, std::hash<int>,
442                                       std::equal_to<int>, min_allocator<int>> C;
443         typedef int P;
444         typedef C::const_local_iterator I;
445         P a[] =
446         {
447             P(1),
448             P(2),
449             P(3),
450             P(4),
451             P(1),
452             P(2)
453         };
454         const C c(a, a + sizeof(a)/sizeof(a[0]));
455         assert(c.bucket_count() >= 7);
456         C::size_type b = c.bucket(0);
457         I i = c.cbegin(b);
458         I j = c.cend(b);
459         assert(std::distance(i, j) == 0);
460 
461         b = c.bucket(1);
462         i = c.cbegin(b);
463         j = c.cend(b);
464         assert(std::distance(i, j) == 2);
465         assert(*i == 1);
466         ++i;
467         assert(*i == 1);
468 
469         b = c.bucket(2);
470         i = c.cbegin(b);
471         j = c.cend(b);
472         assert(std::distance(i, j) == 2);
473         assert(*i == 2);
474         ++i;
475         assert(*i == 2);
476 
477         b = c.bucket(3);
478         i = c.cbegin(b);
479         j = c.cend(b);
480         assert(std::distance(i, j) == 1);
481         assert(*i == 3);
482 
483         b = c.bucket(4);
484         i = c.cbegin(b);
485         j = c.cend(b);
486         assert(std::distance(i, j) == 1);
487         assert(*i == 4);
488 
489         b = c.bucket(5);
490         i = c.cbegin(b);
491         j = c.cend(b);
492         assert(std::distance(i, j) == 0);
493 
494         b = c.bucket(6);
495         i = c.cbegin(b);
496         j = c.cend(b);
497         assert(std::distance(i, j) == 0);
498     }
499 #endif
500 }
501