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

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