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 "test_macros.h"
27
28int 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        LIBCPP_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        *i = 2;
58
59        b = c.bucket(2);
60        i = c.begin(b);
61        j = c.end(b);
62        assert(std::distance(i, j) == 2);
63        assert(*i == 2);
64        ++i;
65        assert(*i == 2);
66
67        b = c.bucket(3);
68        i = c.begin(b);
69        j = c.end(b);
70        assert(std::distance(i, j) == 1);
71        assert(*i == 3);
72
73        b = c.bucket(4);
74        i = c.begin(b);
75        j = c.end(b);
76        assert(std::distance(i, j) == 1);
77        assert(*i == 4);
78
79        b = c.bucket(5);
80        i = c.begin(b);
81        j = c.end(b);
82        assert(std::distance(i, j) == 0);
83
84        b = c.bucket(6);
85        i = c.begin(b);
86        j = c.end(b);
87        assert(std::distance(i, j) == 0);
88    }
89    {
90        typedef std::unordered_multiset<int> C;
91        typedef int P;
92        typedef C::const_local_iterator I;
93        P a[] =
94        {
95            P(1),
96            P(2),
97            P(3),
98            P(4),
99            P(1),
100            P(2)
101        };
102        const C c(a, a + sizeof(a)/sizeof(a[0]));
103        LIBCPP_ASSERT(c.bucket_count() == 7);
104        C::size_type b = c.bucket(0);
105        I i = c.begin(b);
106        I j = c.end(b);
107        assert(std::distance(i, j) == 0);
108
109        b = c.bucket(1);
110        i = c.begin(b);
111        j = c.end(b);
112        assert(std::distance(i, j) == 2);
113        assert(*i == 1);
114        ++i;
115        assert(*i == 1);
116
117        b = c.bucket(2);
118        i = c.begin(b);
119        j = c.end(b);
120        assert(std::distance(i, j) == 2);
121        assert(*i == 2);
122        ++i;
123        assert(*i == 2);
124
125        b = c.bucket(3);
126        i = c.begin(b);
127        j = c.end(b);
128        assert(std::distance(i, j) == 1);
129        assert(*i == 3);
130
131        b = c.bucket(4);
132        i = c.begin(b);
133        j = c.end(b);
134        assert(std::distance(i, j) == 1);
135        assert(*i == 4);
136
137        b = c.bucket(5);
138        i = c.begin(b);
139        j = c.end(b);
140        assert(std::distance(i, j) == 0);
141
142        b = c.bucket(6);
143        i = c.begin(b);
144        j = c.end(b);
145        assert(std::distance(i, j) == 0);
146    }
147    {
148        typedef std::unordered_multiset<int> C;
149        typedef int P;
150        typedef C::const_local_iterator I;
151        P a[] =
152        {
153            P(1),
154            P(2),
155            P(3),
156            P(4),
157            P(1),
158            P(2)
159        };
160        C c(a, a + sizeof(a)/sizeof(a[0]));
161        LIBCPP_ASSERT(c.bucket_count() == 7);
162        C::size_type b = c.bucket(0);
163        I i = c.cbegin(b);
164        I j = c.cend(b);
165        assert(std::distance(i, j) == 0);
166
167        b = c.bucket(1);
168        i = c.cbegin(b);
169        j = c.cend(b);
170        assert(std::distance(i, j) == 2);
171        assert(*i == 1);
172        ++i;
173        assert(*i == 1);
174
175        b = c.bucket(2);
176        i = c.cbegin(b);
177        j = c.cend(b);
178        assert(std::distance(i, j) == 2);
179        assert(*i == 2);
180        ++i;
181        assert(*i == 2);
182
183        b = c.bucket(3);
184        i = c.cbegin(b);
185        j = c.cend(b);
186        assert(std::distance(i, j) == 1);
187        assert(*i == 3);
188
189        b = c.bucket(4);
190        i = c.cbegin(b);
191        j = c.cend(b);
192        assert(std::distance(i, j) == 1);
193        assert(*i == 4);
194
195        b = c.bucket(5);
196        i = c.cbegin(b);
197        j = c.cend(b);
198        assert(std::distance(i, j) == 0);
199
200        b = c.bucket(6);
201        i = c.cbegin(b);
202        j = c.cend(b);
203        assert(std::distance(i, j) == 0);
204    }
205    {
206        typedef std::unordered_multiset<int> C;
207        typedef int P;
208        typedef C::const_local_iterator I;
209        P a[] =
210        {
211            P(1),
212            P(2),
213            P(3),
214            P(4),
215            P(1),
216            P(2)
217        };
218        const C c(a, a + sizeof(a)/sizeof(a[0]));
219        LIBCPP_ASSERT(c.bucket_count() == 7);
220        C::size_type b = c.bucket(0);
221        I i = c.cbegin(b);
222        I j = c.cend(b);
223        assert(std::distance(i, j) == 0);
224
225        b = c.bucket(1);
226        i = c.cbegin(b);
227        j = c.cend(b);
228        assert(std::distance(i, j) == 2);
229        assert(*i == 1);
230        ++i;
231        assert(*i == 1);
232
233        b = c.bucket(2);
234        i = c.cbegin(b);
235        j = c.cend(b);
236        assert(std::distance(i, j) == 2);
237        assert(*i == 2);
238        ++i;
239        assert(*i == 2);
240
241        b = c.bucket(3);
242        i = c.cbegin(b);
243        j = c.cend(b);
244        assert(std::distance(i, j) == 1);
245        assert(*i == 3);
246
247        b = c.bucket(4);
248        i = c.cbegin(b);
249        j = c.cend(b);
250        assert(std::distance(i, j) == 1);
251        assert(*i == 4);
252
253        b = c.bucket(5);
254        i = c.cbegin(b);
255        j = c.cend(b);
256        assert(std::distance(i, j) == 0);
257
258        b = c.bucket(6);
259        i = c.cbegin(b);
260        j = c.cend(b);
261        assert(std::distance(i, j) == 0);
262    }
263}
264