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

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