llvm-project

lower_bound.pass.cpp
374 строки · 11.4 Кб
Перенос по словам
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

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

238
    V ar[] =
239
    {
240
        V(5, 5),
241
        V(7, 6),
242
        V(9, 7),
243
        V(11, 8),
244
        V(13, 9),
245
        V(15, 10),
246
        V(17, 11),
247
        V(19, 12)
248
    };
249
    M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
250
    R r = m.lower_bound(5);
251
    assert(r == m.begin());
252
    r = m.lower_bound(7);
253
    assert(r == std::next(m.begin()));
254
    r = m.lower_bound(9);
255
    assert(r == std::next(m.begin(), 2));
256
    r = m.lower_bound(11);
257
    assert(r == std::next(m.begin(), 3));
258
    r = m.lower_bound(13);
259
    assert(r == std::next(m.begin(), 4));
260
    r = m.lower_bound(15);
261
    assert(r == std::next(m.begin(), 5));
262
    r = m.lower_bound(17);
263
    assert(r == std::next(m.begin(), 6));
264
    r = m.lower_bound(19);
265
    assert(r == std::next(m.begin(), 7));
266
    r = m.lower_bound(4);
267
    assert(r == std::next(m.begin(), 0));
268
    r = m.lower_bound(6);
269
    assert(r == std::next(m.begin(), 1));
270
    r = m.lower_bound(8);
271
    assert(r == std::next(m.begin(), 2));
272
    r = m.lower_bound(10);
273
    assert(r == std::next(m.begin(), 3));
274
    r = m.lower_bound(12);
275
    assert(r == std::next(m.begin(), 4));
276
    r = m.lower_bound(14);
277
    assert(r == std::next(m.begin(), 5));
278
    r = m.lower_bound(16);
279
    assert(r == std::next(m.begin(), 6));
280
    r = m.lower_bound(18);
281
    assert(r == std::next(m.begin(), 7));
282
    r = m.lower_bound(20);
283
    assert(r == std::next(m.begin(), 8));
284

285
    r = m.lower_bound(C2Int(5));
286
    assert(r == m.begin());
287
    r = m.lower_bound(C2Int(7));
288
    assert(r == std::next(m.begin()));
289
    r = m.lower_bound(C2Int(9));
290
    assert(r == std::next(m.begin(), 2));
291
    r = m.lower_bound(C2Int(11));
292
    assert(r == std::next(m.begin(), 3));
293
    r = m.lower_bound(C2Int(13));
294
    assert(r == std::next(m.begin(), 4));
295
    r = m.lower_bound(C2Int(15));
296
    assert(r == std::next(m.begin(), 5));
297
    r = m.lower_bound(C2Int(17));
298
    assert(r == std::next(m.begin(), 6));
299
    r = m.lower_bound(C2Int(19));
300
    assert(r == std::next(m.begin(), 7));
301
    r = m.lower_bound(C2Int(4));
302
    assert(r == std::next(m.begin(), 0));
303
    r = m.lower_bound(C2Int(6));
304
    assert(r == std::next(m.begin(), 1));
305
    r = m.lower_bound(C2Int(8));
306
    assert(r == std::next(m.begin(), 2));
307
    r = m.lower_bound(C2Int(10));
308
    assert(r == std::next(m.begin(), 3));
309
    r = m.lower_bound(C2Int(12));
310
    assert(r == std::next(m.begin(), 4));
311
    r = m.lower_bound(C2Int(14));
312
    assert(r == std::next(m.begin(), 5));
313
    r = m.lower_bound(C2Int(16));
314
    assert(r == std::next(m.begin(), 6));
315
    r = m.lower_bound(C2Int(18));
316
    assert(r == std::next(m.begin(), 7));
317
    r = m.lower_bound(C2Int(20));
318
    assert(r == std::next(m.begin(), 8));
319
    }
320

321
    {
322
    typedef PrivateConstructor PC;
323
    typedef std::map<PC, double, std::less<>> M;
324
    typedef M::iterator R;
325

326
    M m;
327
    m [ PC::make(5)  ] = 5;
328
    m [ PC::make(7)  ] = 6;
329
    m [ PC::make(9)  ] = 7;
330
    m [ PC::make(11) ] = 8;
331
    m [ PC::make(13) ] = 9;
332
    m [ PC::make(15) ] = 10;
333
    m [ PC::make(17) ] = 11;
334
    m [ PC::make(19) ] = 12;
335

336
    R r = m.lower_bound(5);
337
    assert(r == m.begin());
338
    r = m.lower_bound(7);
339
    assert(r == std::next(m.begin()));
340
    r = m.lower_bound(9);
341
    assert(r == std::next(m.begin(), 2));
342
    r = m.lower_bound(11);
343
    assert(r == std::next(m.begin(), 3));
344
    r = m.lower_bound(13);
345
    assert(r == std::next(m.begin(), 4));
346
    r = m.lower_bound(15);
347
    assert(r == std::next(m.begin(), 5));
348
    r = m.lower_bound(17);
349
    assert(r == std::next(m.begin(), 6));
350
    r = m.lower_bound(19);
351
    assert(r == std::next(m.begin(), 7));
352
    r = m.lower_bound(4);
353
    assert(r == std::next(m.begin(), 0));
354
    r = m.lower_bound(6);
355
    assert(r == std::next(m.begin(), 1));
356
    r = m.lower_bound(8);
357
    assert(r == std::next(m.begin(), 2));
358
    r = m.lower_bound(10);
359
    assert(r == std::next(m.begin(), 3));
360
    r = m.lower_bound(12);
361
    assert(r == std::next(m.begin(), 4));
362
    r = m.lower_bound(14);
363
    assert(r == std::next(m.begin(), 5));
364
    r = m.lower_bound(16);
365
    assert(r == std::next(m.begin(), 6));
366
    r = m.lower_bound(18);
367
    assert(r == std::next(m.begin(), 7));
368
    r = m.lower_bound(20);
369
    assert(r == std::next(m.begin(), 8));
370
    }
371
#endif
372

373
  return 0;
374
}
375
llvm-project

Использование cookies
