llvm-project

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 multiset
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
    {
26
        typedef int V;
27
        typedef std::multiset<int> M;
28
        {
29
            typedef M::iterator R;
30
            V ar[] =
31
            {
32
                5,
33
                5,
34
                5,
35
                7,
36
                7,
37
                7,
38
                9,
39
                9,
40
                9
41
            };
42
            M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
43
            R r = m.lower_bound(4);
44
            assert(r == std::next(m.begin(), 0));
45
            r = m.lower_bound(5);
46
            assert(r == std::next(m.begin(), 0));
47
            r = m.lower_bound(6);
48
            assert(r == std::next(m.begin(), 3));
49
            r = m.lower_bound(7);
50
            assert(r == std::next(m.begin(), 3));
51
            r = m.lower_bound(8);
52
            assert(r == std::next(m.begin(), 6));
53
            r = m.lower_bound(9);
54
            assert(r == std::next(m.begin(), 6));
55
            r = m.lower_bound(11);
56
            assert(r == std::next(m.begin(), 9));
57
        }
58
        {
59
            typedef M::const_iterator R;
60
            V ar[] =
61
            {
62
                5,
63
                5,
64
                5,
65
                7,
66
                7,
67
                7,
68
                9,
69
                9,
70
                9
71
            };
72
            const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
73
            R r = m.lower_bound(4);
74
            assert(r == std::next(m.begin(), 0));
75
            r = m.lower_bound(5);
76
            assert(r == std::next(m.begin(), 0));
77
            r = m.lower_bound(6);
78
            assert(r == std::next(m.begin(), 3));
79
            r = m.lower_bound(7);
80
            assert(r == std::next(m.begin(), 3));
81
            r = m.lower_bound(8);
82
            assert(r == std::next(m.begin(), 6));
83
            r = m.lower_bound(9);
84
            assert(r == std::next(m.begin(), 6));
85
            r = m.lower_bound(11);
86
            assert(r == std::next(m.begin(), 9));
87
        }
88
    }
89
#if TEST_STD_VER >= 11
90
    {
91
        typedef int V;
92
        typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
93
        {
94
            typedef M::iterator R;
95
            V ar[] =
96
            {
97
                5,
98
                5,
99
                5,
100
                7,
101
                7,
102
                7,
103
                9,
104
                9,
105
                9
106
            };
107
            M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
108
            R r = m.lower_bound(4);
109
            assert(r == std::next(m.begin(), 0));
110
            r = m.lower_bound(5);
111
            assert(r == std::next(m.begin(), 0));
112
            r = m.lower_bound(6);
113
            assert(r == std::next(m.begin(), 3));
114
            r = m.lower_bound(7);
115
            assert(r == std::next(m.begin(), 3));
116
            r = m.lower_bound(8);
117
            assert(r == std::next(m.begin(), 6));
118
            r = m.lower_bound(9);
119
            assert(r == std::next(m.begin(), 6));
120
            r = m.lower_bound(11);
121
            assert(r == std::next(m.begin(), 9));
122
        }
123
        {
124
            typedef M::const_iterator R;
125
            V ar[] =
126
            {
127
                5,
128
                5,
129
                5,
130
                7,
131
                7,
132
                7,
133
                9,
134
                9,
135
                9
136
            };
137
            const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
138
            R r = m.lower_bound(4);
139
            assert(r == std::next(m.begin(), 0));
140
            r = m.lower_bound(5);
141
            assert(r == std::next(m.begin(), 0));
142
            r = m.lower_bound(6);
143
            assert(r == std::next(m.begin(), 3));
144
            r = m.lower_bound(7);
145
            assert(r == std::next(m.begin(), 3));
146
            r = m.lower_bound(8);
147
            assert(r == std::next(m.begin(), 6));
148
            r = m.lower_bound(9);
149
            assert(r == std::next(m.begin(), 6));
150
            r = m.lower_bound(11);
151
            assert(r == std::next(m.begin(), 9));
152
        }
153
    }
154
#endif
155
#if TEST_STD_VER > 11
156
    {
157
    typedef int V;
158
    typedef std::multiset<V, std::less<>> M;
159

160
    typedef M::iterator R;
161
    V ar[] =
162
    {
163
        5,
164
        5,
165
        5,
166
        7,
167
        7,
168
        7,
169
        9,
170
        9,
171
        9
172
    };
173
    M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
174

175
    R r = m.lower_bound(4);
176
    assert(r == std::next(m.begin(), 0));
177
    r = m.lower_bound(5);
178
    assert(r == std::next(m.begin(), 0));
179
    r = m.lower_bound(6);
180
    assert(r == std::next(m.begin(), 3));
181
    r = m.lower_bound(7);
182
    assert(r == std::next(m.begin(), 3));
183
    r = m.lower_bound(8);
184
    assert(r == std::next(m.begin(), 6));
185
    r = m.lower_bound(9);
186
    assert(r == std::next(m.begin(), 6));
187
    r = m.lower_bound(11);
188
    assert(r == std::next(m.begin(), 9));
189
    }
190

191
    {
192
    typedef PrivateConstructor V;
193
    typedef std::multiset<V, std::less<>> M;
194
    typedef M::iterator R;
195

196
    M m;
197
    m.insert ( V::make ( 5 ));
198
    m.insert ( V::make ( 5 ));
199
    m.insert ( V::make ( 5 ));
200
    m.insert ( V::make ( 7 ));
201
    m.insert ( V::make ( 7 ));
202
    m.insert ( V::make ( 7 ));
203
    m.insert ( V::make ( 9 ));
204
    m.insert ( V::make ( 9 ));
205
    m.insert ( V::make ( 9 ));
206

207
    R r = m.lower_bound(4);
208
    assert(r == std::next(m.begin(), 0));
209
    r = m.lower_bound(5);
210
    assert(r == std::next(m.begin(), 0));
211
    r = m.lower_bound(6);
212
    assert(r == std::next(m.begin(), 3));
213
    r = m.lower_bound(7);
214
    assert(r == std::next(m.begin(), 3));
215
    r = m.lower_bound(8);
216
    assert(r == std::next(m.begin(), 6));
217
    r = m.lower_bound(9);
218
    assert(r == std::next(m.begin(), 6));
219
    r = m.lower_bound(11);
220
    assert(r == std::next(m.begin(), 9));
221
    }
222
#endif
223

224
  return 0;
225
}
226