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

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