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

source code of libcxx/test/std/containers/associative/map/map.ops/equal_range.pass.cpp