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_multimap
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 <set>
25#include <cassert>
26
27#include "test_macros.h"
28#include "min_allocator.h"
29
30int main(int, char**) {
31 {
32 typedef std::unordered_multimap<int, std::string> C;
33 typedef std::pair<int, std::string> P;
34 typedef C::local_iterator I;
35 P a[] = {
36 P(1, "one"),
37 P(2, "two"),
38 P(3, "three"),
39 P(4, "four"),
40 P(1, "four"),
41 P(2, "four"),
42 };
43 C c(a, a + sizeof(a) / sizeof(a[0]));
44 assert(c.bucket_count() >= 7);
45 C::size_type b = c.bucket(key: 0);
46 I i = c.begin(n: b);
47 I j = c.end(n: b);
48 assert(std::distance(i, j) == 0);
49
50 b = c.bucket(key: 1);
51 i = c.begin(n: b);
52 j = c.end(n: b);
53 assert(std::distance(i, j) == 2);
54 {
55 std::set<std::string> s;
56 s.insert(x: "one");
57 s.insert(x: "four");
58 for (int n = 0; n < 2; ++n) {
59 assert(i->first == 1);
60 assert(s.find(i->second) != s.end());
61 s.erase(position: s.find(x: i->second));
62 ++i;
63 }
64 }
65
66 b = c.bucket(key: 2);
67 i = c.begin(n: b);
68 j = c.end(n: b);
69 assert(std::distance(i, j) == 2);
70 {
71 std::set<std::string> s;
72 s.insert(x: "two");
73 s.insert(x: "four");
74 for (int n = 0; n < 2; ++n) {
75 assert(i->first == 2);
76 assert(s.find(i->second) != s.end());
77 s.erase(position: s.find(x: i->second));
78 ++i;
79 }
80 }
81
82 b = c.bucket(key: 3);
83 i = c.begin(n: b);
84 j = c.end(n: b);
85 assert(std::distance(i, j) == 1);
86 assert(i->first == 3);
87 assert(i->second == "three");
88
89 b = c.bucket(key: 4);
90 i = c.begin(n: b);
91 j = c.end(n: b);
92 assert(std::distance(i, j) == 1);
93 assert(i->first == 4);
94 assert(i->second == "four");
95
96 b = c.bucket(key: 5);
97 i = c.begin(n: b);
98 j = c.end(n: b);
99 assert(std::distance(i, j) == 0);
100
101 b = c.bucket(key: 6);
102 i = c.begin(n: b);
103 j = c.end(n: b);
104 assert(std::distance(i, j) == 0);
105 }
106 {
107 typedef std::unordered_multimap<int, std::string> C;
108 typedef std::pair<int, std::string> P;
109 typedef C::const_local_iterator I;
110 P a[] = {
111 P(1, "one"),
112 P(2, "two"),
113 P(3, "three"),
114 P(4, "four"),
115 P(1, "four"),
116 P(2, "four"),
117 };
118 const C c(a, a + sizeof(a) / sizeof(a[0]));
119 assert(c.bucket_count() >= 7);
120 C::size_type b = c.bucket(key: 0);
121 I i = c.begin(n: b);
122 I j = c.end(n: b);
123 assert(std::distance(i, j) == 0);
124
125 b = c.bucket(key: 1);
126 i = c.begin(n: b);
127 j = c.end(n: b);
128 assert(std::distance(i, j) == 2);
129 {
130 std::set<std::string> s;
131 s.insert(x: "one");
132 s.insert(x: "four");
133 for (int n = 0; n < 2; ++n) {
134 assert(i->first == 1);
135 assert(s.find(i->second) != s.end());
136 s.erase(position: s.find(x: i->second));
137 ++i;
138 }
139 }
140
141 b = c.bucket(key: 2);
142 i = c.begin(n: b);
143 j = c.end(n: b);
144 assert(std::distance(i, j) == 2);
145 {
146 std::set<std::string> s;
147 s.insert(x: "two");
148 s.insert(x: "four");
149 for (int n = 0; n < 2; ++n) {
150 assert(i->first == 2);
151 assert(s.find(i->second) != s.end());
152 s.erase(position: s.find(x: i->second));
153 ++i;
154 }
155 }
156
157 b = c.bucket(key: 3);
158 i = c.begin(n: b);
159 j = c.end(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.begin(n: b);
166 j = c.end(n: b);
167 assert(std::distance(i, j) == 1);
168 assert(i->first == 4);
169 assert(i->second == "four");
170
171 b = c.bucket(key: 5);
172 i = c.begin(n: b);
173 j = c.end(n: b);
174 assert(std::distance(i, j) == 0);
175
176 b = c.bucket(key: 6);
177 i = c.begin(n: b);
178 j = c.end(n: b);
179 assert(std::distance(i, j) == 0);
180 }
181 {
182 typedef std::unordered_multimap<int, std::string> C;
183 typedef std::pair<int, std::string> P;
184 typedef C::const_local_iterator I;
185 P a[] = {
186 P(1, "one"),
187 P(2, "two"),
188 P(3, "three"),
189 P(4, "four"),
190 P(1, "four"),
191 P(2, "four"),
192 };
193 C c(a, a + sizeof(a) / sizeof(a[0]));
194 assert(c.bucket_count() >= 7);
195 C::size_type b = c.bucket(key: 0);
196 I i = c.cbegin(n: b);
197 I j = c.cend(n: b);
198 assert(std::distance(i, j) == 0);
199
200 b = c.bucket(key: 1);
201 i = c.cbegin(n: b);
202 j = c.cend(n: b);
203 assert(std::distance(i, j) == 2);
204 {
205 std::set<std::string> s;
206 s.insert(x: "one");
207 s.insert(x: "four");
208 for (int n = 0; n < 2; ++n) {
209 assert(i->first == 1);
210 assert(s.find(i->second) != s.end());
211 s.erase(position: s.find(x: i->second));
212 ++i;
213 }
214 }
215
216 b = c.bucket(key: 2);
217 i = c.cbegin(n: b);
218 j = c.cend(n: b);
219 assert(std::distance(i, j) == 2);
220 {
221 std::set<std::string> s;
222 s.insert(x: "two");
223 s.insert(x: "four");
224 for (int n = 0; n < 2; ++n) {
225 assert(i->first == 2);
226 assert(s.find(i->second) != s.end());
227 s.erase(position: s.find(x: i->second));
228 ++i;
229 }
230 }
231
232 b = c.bucket(key: 3);
233 i = c.cbegin(n: b);
234 j = c.cend(n: b);
235 assert(std::distance(i, j) == 1);
236 assert(i->first == 3);
237 assert(i->second == "three");
238
239 b = c.bucket(key: 4);
240 i = c.cbegin(n: b);
241 j = c.cend(n: b);
242 assert(std::distance(i, j) == 1);
243 assert(i->first == 4);
244 assert(i->second == "four");
245
246 b = c.bucket(key: 5);
247 i = c.cbegin(n: b);
248 j = c.cend(n: b);
249 assert(std::distance(i, j) == 0);
250
251 b = c.bucket(key: 6);
252 i = c.cbegin(n: b);
253 j = c.cend(n: b);
254 assert(std::distance(i, j) == 0);
255 }
256 {
257 typedef std::unordered_multimap<int, std::string> C;
258 typedef std::pair<int, std::string> P;
259 typedef C::const_local_iterator I;
260 P a[] = {
261 P(1, "one"),
262 P(2, "two"),
263 P(3, "three"),
264 P(4, "four"),
265 P(1, "four"),
266 P(2, "four"),
267 };
268 const C c(a, a + sizeof(a) / sizeof(a[0]));
269 assert(c.bucket_count() >= 7);
270 C::size_type b = c.bucket(key: 0);
271 I i = c.cbegin(n: b);
272 I j = c.cend(n: b);
273 assert(std::distance(i, j) == 0);
274
275 b = c.bucket(key: 1);
276 i = c.cbegin(n: b);
277 j = c.cend(n: b);
278 assert(std::distance(i, j) == 2);
279 {
280 std::set<std::string> s;
281 s.insert(x: "one");
282 s.insert(x: "four");
283 for (int n = 0; n < 2; ++n) {
284 assert(i->first == 1);
285 assert(s.find(i->second) != s.end());
286 s.erase(position: s.find(x: i->second));
287 ++i;
288 }
289 }
290
291 b = c.bucket(key: 2);
292 i = c.cbegin(n: b);
293 j = c.cend(n: b);
294 assert(std::distance(i, j) == 2);
295 {
296 std::set<std::string> s;
297 s.insert(x: "two");
298 s.insert(x: "four");
299 for (int n = 0; n < 2; ++n) {
300 assert(i->first == 2);
301 assert(s.find(i->second) != s.end());
302 s.erase(position: s.find(x: i->second));
303 ++i;
304 }
305 }
306
307 b = c.bucket(key: 3);
308 i = c.cbegin(n: b);
309 j = c.cend(n: b);
310 assert(std::distance(i, j) == 1);
311 assert(i->first == 3);
312 assert(i->second == "three");
313
314 b = c.bucket(key: 4);
315 i = c.cbegin(n: b);
316 j = c.cend(n: b);
317 assert(std::distance(i, j) == 1);
318 assert(i->first == 4);
319 assert(i->second == "four");
320
321 b = c.bucket(key: 5);
322 i = c.cbegin(n: b);
323 j = c.cend(n: b);
324 assert(std::distance(i, j) == 0);
325
326 b = c.bucket(key: 6);
327 i = c.cbegin(n: b);
328 j = c.cend(n: b);
329 assert(std::distance(i, j) == 0);
330 }
331#if TEST_STD_VER >= 11
332 {
333 typedef std::unordered_multimap<int,
334 std::string,
335 std::hash<int>,
336 std::equal_to<int>,
337 min_allocator<std::pair<const int, std::string>>>
338 C;
339 typedef std::pair<int, std::string> P;
340 typedef C::local_iterator I;
341 P a[] = {
342 P(1, "one"),
343 P(2, "two"),
344 P(3, "three"),
345 P(4, "four"),
346 P(1, "four"),
347 P(2, "four"),
348 };
349 C c(a, a + sizeof(a) / sizeof(a[0]));
350 assert(c.bucket_count() >= 7);
351 C::size_type b = c.bucket(0);
352 I i = c.begin(b);
353 I j = c.end(b);
354 assert(std::distance(i, j) == 0);
355
356 b = c.bucket(1);
357 i = c.begin(b);
358 j = c.end(b);
359 assert(std::distance(i, j) == 2);
360 {
361 std::set<std::string> s;
362 s.insert("one");
363 s.insert("four");
364 for (int n = 0; n < 2; ++n) {
365 assert(i->first == 1);
366 assert(s.find(i->second) != s.end());
367 s.erase(s.find(i->second));
368 ++i;
369 }
370 }
371
372 b = c.bucket(2);
373 i = c.begin(b);
374 j = c.end(b);
375 assert(std::distance(i, j) == 2);
376 {
377 std::set<std::string> s;
378 s.insert("two");
379 s.insert("four");
380 for (int n = 0; n < 2; ++n) {
381 assert(i->first == 2);
382 assert(s.find(i->second) != s.end());
383 s.erase(s.find(i->second));
384 ++i;
385 }
386 }
387
388 b = c.bucket(3);
389 i = c.begin(b);
390 j = c.end(b);
391 assert(std::distance(i, j) == 1);
392 assert(i->first == 3);
393 assert(i->second == "three");
394
395 b = c.bucket(4);
396 i = c.begin(b);
397 j = c.end(b);
398 assert(std::distance(i, j) == 1);
399 assert(i->first == 4);
400 assert(i->second == "four");
401
402 b = c.bucket(5);
403 i = c.begin(b);
404 j = c.end(b);
405 assert(std::distance(i, j) == 0);
406
407 b = c.bucket(6);
408 i = c.begin(b);
409 j = c.end(b);
410 assert(std::distance(i, j) == 0);
411 }
412 {
413 typedef std::unordered_multimap<int,
414 std::string,
415 std::hash<int>,
416 std::equal_to<int>,
417 min_allocator<std::pair<const int, std::string>>>
418 C;
419 typedef std::pair<int, std::string> P;
420 typedef C::const_local_iterator I;
421 P a[] = {
422 P(1, "one"),
423 P(2, "two"),
424 P(3, "three"),
425 P(4, "four"),
426 P(1, "four"),
427 P(2, "four"),
428 };
429 const C c(a, a + sizeof(a) / sizeof(a[0]));
430 assert(c.bucket_count() >= 7);
431 C::size_type b = c.bucket(0);
432 I i = c.begin(b);
433 I j = c.end(b);
434 assert(std::distance(i, j) == 0);
435
436 b = c.bucket(1);
437 i = c.begin(b);
438 j = c.end(b);
439 assert(std::distance(i, j) == 2);
440 {
441 std::set<std::string> s;
442 s.insert("one");
443 s.insert("four");
444 for (int n = 0; n < 2; ++n) {
445 assert(i->first == 1);
446 assert(s.find(i->second) != s.end());
447 s.erase(s.find(i->second));
448 ++i;
449 }
450 }
451
452 b = c.bucket(2);
453 i = c.begin(b);
454 j = c.end(b);
455 assert(std::distance(i, j) == 2);
456 {
457 std::set<std::string> s;
458 s.insert("two");
459 s.insert("four");
460 for (int n = 0; n < 2; ++n) {
461 assert(i->first == 2);
462 assert(s.find(i->second) != s.end());
463 s.erase(s.find(i->second));
464 ++i;
465 }
466 }
467
468 b = c.bucket(3);
469 i = c.begin(b);
470 j = c.end(b);
471 assert(std::distance(i, j) == 1);
472 assert(i->first == 3);
473 assert(i->second == "three");
474
475 b = c.bucket(4);
476 i = c.begin(b);
477 j = c.end(b);
478 assert(std::distance(i, j) == 1);
479 assert(i->first == 4);
480 assert(i->second == "four");
481
482 b = c.bucket(5);
483 i = c.begin(b);
484 j = c.end(b);
485 assert(std::distance(i, j) == 0);
486
487 b = c.bucket(6);
488 i = c.begin(b);
489 j = c.end(b);
490 assert(std::distance(i, j) == 0);
491 }
492 {
493 typedef std::unordered_multimap<int,
494 std::string,
495 std::hash<int>,
496 std::equal_to<int>,
497 min_allocator<std::pair<const int, std::string>>>
498 C;
499 typedef std::pair<int, std::string> P;
500 typedef C::const_local_iterator I;
501 P a[] = {
502 P(1, "one"),
503 P(2, "two"),
504 P(3, "three"),
505 P(4, "four"),
506 P(1, "four"),
507 P(2, "four"),
508 };
509 C c(a, a + sizeof(a) / sizeof(a[0]));
510 assert(c.bucket_count() >= 7);
511 C::size_type b = c.bucket(0);
512 I i = c.cbegin(b);
513 I j = c.cend(b);
514 assert(std::distance(i, j) == 0);
515
516 b = c.bucket(1);
517 i = c.cbegin(b);
518 j = c.cend(b);
519 assert(std::distance(i, j) == 2);
520 {
521 std::set<std::string> s;
522 s.insert("one");
523 s.insert("four");
524 for (int n = 0; n < 2; ++n) {
525 assert(i->first == 1);
526 assert(s.find(i->second) != s.end());
527 s.erase(s.find(i->second));
528 ++i;
529 }
530 }
531
532 b = c.bucket(2);
533 i = c.cbegin(b);
534 j = c.cend(b);
535 assert(std::distance(i, j) == 2);
536 {
537 std::set<std::string> s;
538 s.insert("two");
539 s.insert("four");
540 for (int n = 0; n < 2; ++n) {
541 assert(i->first == 2);
542 assert(s.find(i->second) != s.end());
543 s.erase(s.find(i->second));
544 ++i;
545 }
546 }
547
548 b = c.bucket(3);
549 i = c.cbegin(b);
550 j = c.cend(b);
551 assert(std::distance(i, j) == 1);
552 assert(i->first == 3);
553 assert(i->second == "three");
554
555 b = c.bucket(4);
556 i = c.cbegin(b);
557 j = c.cend(b);
558 assert(std::distance(i, j) == 1);
559 assert(i->first == 4);
560 assert(i->second == "four");
561
562 b = c.bucket(5);
563 i = c.cbegin(b);
564 j = c.cend(b);
565 assert(std::distance(i, j) == 0);
566
567 b = c.bucket(6);
568 i = c.cbegin(b);
569 j = c.cend(b);
570 assert(std::distance(i, j) == 0);
571 }
572 {
573 typedef std::unordered_multimap<int,
574 std::string,
575 std::hash<int>,
576 std::equal_to<int>,
577 min_allocator<std::pair<const int, std::string>>>
578 C;
579 typedef std::pair<int, std::string> P;
580 typedef C::const_local_iterator I;
581 P a[] = {
582 P(1, "one"),
583 P(2, "two"),
584 P(3, "three"),
585 P(4, "four"),
586 P(1, "four"),
587 P(2, "four"),
588 };
589 const C c(a, a + sizeof(a) / sizeof(a[0]));
590 assert(c.bucket_count() >= 7);
591 C::size_type b = c.bucket(0);
592 I i = c.cbegin(b);
593 I j = c.cend(b);
594 assert(std::distance(i, j) == 0);
595
596 b = c.bucket(1);
597 i = c.cbegin(b);
598 j = c.cend(b);
599 assert(std::distance(i, j) == 2);
600 {
601 std::set<std::string> s;
602 s.insert("one");
603 s.insert("four");
604 for (int n = 0; n < 2; ++n) {
605 assert(i->first == 1);
606 assert(s.find(i->second) != s.end());
607 s.erase(s.find(i->second));
608 ++i;
609 }
610 }
611
612 b = c.bucket(2);
613 i = c.cbegin(b);
614 j = c.cend(b);
615 assert(std::distance(i, j) == 2);
616 {
617 std::set<std::string> s;
618 s.insert("two");
619 s.insert("four");
620 for (int n = 0; n < 2; ++n) {
621 assert(i->first == 2);
622 assert(s.find(i->second) != s.end());
623 s.erase(s.find(i->second));
624 ++i;
625 }
626 }
627
628 b = c.bucket(3);
629 i = c.cbegin(b);
630 j = c.cend(b);
631 assert(std::distance(i, j) == 1);
632 assert(i->first == 3);
633 assert(i->second == "three");
634
635 b = c.bucket(4);
636 i = c.cbegin(b);
637 j = c.cend(b);
638 assert(std::distance(i, j) == 1);
639 assert(i->first == 4);
640 assert(i->second == "four");
641
642 b = c.bucket(5);
643 i = c.cbegin(b);
644 j = c.cend(b);
645 assert(std::distance(i, j) == 0);
646
647 b = c.bucket(6);
648 i = c.cbegin(b);
649 j = c.cend(b);
650 assert(std::distance(i, j) == 0);
651 }
652#endif
653
654 return 0;
655}
656

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