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

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