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