1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <unordered_set>
10
11// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
12// class Alloc = allocator<Value>>
13// class unordered_set
14
15// local_iterator begin (size_type n);
16// local_iterator end (size_type n);
17// const_local_iterator begin (size_type n) const;
18// const_local_iterator end (size_type n) const;
19// const_local_iterator cbegin(size_type n) const;
20// const_local_iterator cend (size_type n) const;
21
22#include <unordered_set>
23#include <cassert>
24
25#include "test_macros.h"
26#include "min_allocator.h"
27
28int main(int, char**) {
29 {
30 typedef std::unordered_set<int> C;
31 typedef int P;
32 typedef C::local_iterator I;
33 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
34 C c(a, a + sizeof(a) / sizeof(a[0]));
35 assert(c.bucket_count() >= 5);
36 C::size_type b = c.bucket(key: 0);
37 I i = c.begin(n: b);
38 I j = c.end(n: b);
39 assert(std::distance(i, j) == 0);
40
41 b = c.bucket(key: 1);
42 i = c.begin(n: b);
43 j = c.end(n: b);
44 assert(std::distance(i, j) == 1);
45 assert(*i == 1);
46
47 b = c.bucket(key: 2);
48 i = c.begin(n: b);
49 j = c.end(n: b);
50 assert(std::distance(i, j) == 1);
51 assert(*i == 2);
52
53 b = c.bucket(key: 3);
54 i = c.begin(n: b);
55 j = c.end(n: b);
56 assert(std::distance(i, j) == 1);
57 assert(*i == 3);
58
59 b = c.bucket(key: 4);
60 i = c.begin(n: b);
61 j = c.end(n: b);
62 assert(std::distance(i, j) == 1);
63 assert(*i == 4);
64 }
65 {
66 typedef std::unordered_set<int> C;
67 typedef int P;
68 typedef C::const_local_iterator I;
69 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
70 const C c(a, a + sizeof(a) / sizeof(a[0]));
71 assert(c.bucket_count() >= 5);
72 C::size_type b = c.bucket(key: 0);
73 I i = c.begin(n: b);
74 I j = c.end(n: b);
75 assert(std::distance(i, j) == 0);
76
77 b = c.bucket(key: 1);
78 i = c.begin(n: b);
79 j = c.end(n: b);
80 assert(std::distance(i, j) == 1);
81 assert(*i == 1);
82
83 b = c.bucket(key: 2);
84 i = c.begin(n: b);
85 j = c.end(n: b);
86 assert(std::distance(i, j) == 1);
87 assert(*i == 2);
88
89 b = c.bucket(key: 3);
90 i = c.begin(n: b);
91 j = c.end(n: b);
92 assert(std::distance(i, j) == 1);
93 assert(*i == 3);
94
95 b = c.bucket(key: 4);
96 i = c.begin(n: b);
97 j = c.end(n: b);
98 assert(std::distance(i, j) == 1);
99 assert(*i == 4);
100 }
101 {
102 typedef std::unordered_set<int> C;
103 typedef int P;
104 typedef C::const_local_iterator I;
105 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
106 C c(a, a + sizeof(a) / sizeof(a[0]));
107 assert(c.bucket_count() >= 5);
108 C::size_type b = c.bucket(key: 0);
109 I i = c.cbegin(n: b);
110 I j = c.cend(n: b);
111 assert(std::distance(i, j) == 0);
112
113 b = c.bucket(key: 1);
114 i = c.cbegin(n: b);
115 j = c.cend(n: b);
116 assert(std::distance(i, j) == 1);
117 assert(*i == 1);
118
119 b = c.bucket(key: 2);
120 i = c.cbegin(n: b);
121 j = c.cend(n: b);
122 assert(std::distance(i, j) == 1);
123 assert(*i == 2);
124
125 b = c.bucket(key: 3);
126 i = c.cbegin(n: b);
127 j = c.cend(n: b);
128 assert(std::distance(i, j) == 1);
129 assert(*i == 3);
130
131 b = c.bucket(key: 4);
132 i = c.cbegin(n: b);
133 j = c.cend(n: b);
134 assert(std::distance(i, j) == 1);
135 assert(*i == 4);
136 }
137 {
138 typedef std::unordered_set<int> C;
139 typedef int P;
140 typedef C::const_local_iterator I;
141 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
142 const C c(a, a + sizeof(a) / sizeof(a[0]));
143 assert(c.bucket_count() >= 5);
144 C::size_type b = c.bucket(key: 0);
145 I i = c.cbegin(n: b);
146 I j = c.cend(n: b);
147 assert(std::distance(i, j) == 0);
148
149 b = c.bucket(key: 1);
150 i = c.cbegin(n: b);
151 j = c.cend(n: b);
152 assert(std::distance(i, j) == 1);
153 assert(*i == 1);
154
155 b = c.bucket(key: 2);
156 i = c.cbegin(n: b);
157 j = c.cend(n: b);
158 assert(std::distance(i, j) == 1);
159 assert(*i == 2);
160
161 b = c.bucket(key: 3);
162 i = c.cbegin(n: b);
163 j = c.cend(n: b);
164 assert(std::distance(i, j) == 1);
165 assert(*i == 3);
166
167 b = c.bucket(key: 4);
168 i = c.cbegin(n: b);
169 j = c.cend(n: b);
170 assert(std::distance(i, j) == 1);
171 assert(*i == 4);
172 }
173#if TEST_STD_VER >= 11
174 {
175 typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
176 typedef int P;
177 typedef C::local_iterator I;
178 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
179 C c(a, a + sizeof(a) / sizeof(a[0]));
180 assert(c.bucket_count() >= 5);
181 C::size_type b = c.bucket(0);
182 I i = c.begin(b);
183 I j = c.end(b);
184 assert(std::distance(i, j) == 0);
185
186 b = c.bucket(1);
187 i = c.begin(b);
188 j = c.end(b);
189 assert(std::distance(i, j) == 1);
190 assert(*i == 1);
191
192 b = c.bucket(2);
193 i = c.begin(b);
194 j = c.end(b);
195 assert(std::distance(i, j) == 1);
196 assert(*i == 2);
197
198 b = c.bucket(3);
199 i = c.begin(b);
200 j = c.end(b);
201 assert(std::distance(i, j) == 1);
202 assert(*i == 3);
203
204 b = c.bucket(4);
205 i = c.begin(b);
206 j = c.end(b);
207 assert(std::distance(i, j) == 1);
208 assert(*i == 4);
209 }
210 {
211 typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
212 typedef int P;
213 typedef C::const_local_iterator I;
214 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
215 const C c(a, a + sizeof(a) / sizeof(a[0]));
216 assert(c.bucket_count() >= 5);
217 C::size_type b = c.bucket(0);
218 I i = c.begin(b);
219 I j = c.end(b);
220 assert(std::distance(i, j) == 0);
221
222 b = c.bucket(1);
223 i = c.begin(b);
224 j = c.end(b);
225 assert(std::distance(i, j) == 1);
226 assert(*i == 1);
227
228 b = c.bucket(2);
229 i = c.begin(b);
230 j = c.end(b);
231 assert(std::distance(i, j) == 1);
232 assert(*i == 2);
233
234 b = c.bucket(3);
235 i = c.begin(b);
236 j = c.end(b);
237 assert(std::distance(i, j) == 1);
238 assert(*i == 3);
239
240 b = c.bucket(4);
241 i = c.begin(b);
242 j = c.end(b);
243 assert(std::distance(i, j) == 1);
244 assert(*i == 4);
245 }
246 {
247 typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
248 typedef int P;
249 typedef C::const_local_iterator I;
250 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
251 C c(a, a + sizeof(a) / sizeof(a[0]));
252 assert(c.bucket_count() >= 5);
253 C::size_type b = c.bucket(0);
254 I i = c.cbegin(b);
255 I j = c.cend(b);
256 assert(std::distance(i, j) == 0);
257
258 b = c.bucket(1);
259 i = c.cbegin(b);
260 j = c.cend(b);
261 assert(std::distance(i, j) == 1);
262 assert(*i == 1);
263
264 b = c.bucket(2);
265 i = c.cbegin(b);
266 j = c.cend(b);
267 assert(std::distance(i, j) == 1);
268 assert(*i == 2);
269
270 b = c.bucket(3);
271 i = c.cbegin(b);
272 j = c.cend(b);
273 assert(std::distance(i, j) == 1);
274 assert(*i == 3);
275
276 b = c.bucket(4);
277 i = c.cbegin(b);
278 j = c.cend(b);
279 assert(std::distance(i, j) == 1);
280 assert(*i == 4);
281 }
282 {
283 typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
284 typedef int P;
285 typedef C::const_local_iterator I;
286 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
287 const C c(a, a + sizeof(a) / sizeof(a[0]));
288 assert(c.bucket_count() >= 5);
289 C::size_type b = c.bucket(0);
290 I i = c.cbegin(b);
291 I j = c.cend(b);
292 assert(std::distance(i, j) == 0);
293
294 b = c.bucket(1);
295 i = c.cbegin(b);
296 j = c.cend(b);
297 assert(std::distance(i, j) == 1);
298 assert(*i == 1);
299
300 b = c.bucket(2);
301 i = c.cbegin(b);
302 j = c.cend(b);
303 assert(std::distance(i, j) == 1);
304 assert(*i == 2);
305
306 b = c.bucket(3);
307 i = c.cbegin(b);
308 j = c.cend(b);
309 assert(std::distance(i, j) == 1);
310 assert(*i == 3);
311
312 b = c.bucket(4);
313 i = c.cbegin(b);
314 j = c.cend(b);
315 assert(std::distance(i, j) == 1);
316 assert(*i == 4);
317 }
318#endif
319
320 return 0;
321}
322

source code of libcxx/test/std/containers/unord/unord.set/local_iterators.pass.cpp