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

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