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