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 upper_bound(const key_type& k);
14
// const_iterator upper_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.upper_bound(4);
44
        assert(r == std::next(m.begin(), 0));
45
        r = m.upper_bound(5);
46
        assert(r == std::next(m.begin(), 3));
47
        r = m.upper_bound(6);
48
        assert(r == std::next(m.begin(), 3));
49
        r = m.upper_bound(7);
50
        assert(r == std::next(m.begin(), 6));
51
        r = m.upper_bound(8);
52
        assert(r == std::next(m.begin(), 6));
53
        r = m.upper_bound(9);
54
        assert(r == std::next(m.begin(), 9));
55
        r = m.upper_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.upper_bound(4);
74
        assert(r == std::next(m.begin(), 0));
75
        r = m.upper_bound(5);
76
        assert(r == std::next(m.begin(), 3));
77
        r = m.upper_bound(6);
78
        assert(r == std::next(m.begin(), 3));
79
        r = m.upper_bound(7);
80
        assert(r == std::next(m.begin(), 6));
81
        r = m.upper_bound(8);
82
        assert(r == std::next(m.begin(), 6));
83
        r = m.upper_bound(9);
84
        assert(r == std::next(m.begin(), 9));
85
        r = m.upper_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.upper_bound(4);
109
        assert(r == std::next(m.begin(), 0));
110
        r = m.upper_bound(5);
111
        assert(r == std::next(m.begin(), 3));
112
        r = m.upper_bound(6);
113
        assert(r == std::next(m.begin(), 3));
114
        r = m.upper_bound(7);
115
        assert(r == std::next(m.begin(), 6));
116
        r = m.upper_bound(8);
117
        assert(r == std::next(m.begin(), 6));
118
        r = m.upper_bound(9);
119
        assert(r == std::next(m.begin(), 9));
120
        r = m.upper_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.upper_bound(4);
139
        assert(r == std::next(m.begin(), 0));
140
        r = m.upper_bound(5);
141
        assert(r == std::next(m.begin(), 3));
142
        r = m.upper_bound(6);
143
        assert(r == std::next(m.begin(), 3));
144
        r = m.upper_bound(7);
145
        assert(r == std::next(m.begin(), 6));
146
        r = m.upper_bound(8);
147
        assert(r == std::next(m.begin(), 6));
148
        r = m.upper_bound(9);
149
        assert(r == std::next(m.begin(), 9));
150
        r = m.upper_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
    R r = m.upper_bound(4);
175
    assert(r == std::next(m.begin(), 0));
176
    r = m.upper_bound(5);
177
    assert(r == std::next(m.begin(), 3));
178
    r = m.upper_bound(6);
179
    assert(r == std::next(m.begin(), 3));
180
    r = m.upper_bound(7);
181
    assert(r == std::next(m.begin(), 6));
182
    r = m.upper_bound(8);
183
    assert(r == std::next(m.begin(), 6));
184
    r = m.upper_bound(9);
185
    assert(r == std::next(m.begin(), 9));
186
    r = m.upper_bound(11);
187
    assert(r == std::next(m.begin(), 9));
188
    }
189

190
    {
191
    typedef PrivateConstructor V;
192
    typedef std::multiset<V, std::less<>> M;
193

194
    typedef M::iterator R;
195
    M m;
196
    m.insert ( V::make ( 5 ));
197
    m.insert ( V::make ( 5 ));
198
    m.insert ( V::make ( 5 ));
199
    m.insert ( V::make ( 7 ));
200
    m.insert ( V::make ( 7 ));
201
    m.insert ( V::make ( 7 ));
202
    m.insert ( V::make ( 9 ));
203
    m.insert ( V::make ( 9 ));
204
    m.insert ( V::make ( 9 ));
205

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

223
  return 0;
224
}
225