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
// <map>
10

11
// class multimap
12

13
//       iterator upper_bound(const key_type& k);
14
// const_iterator upper_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
    typedef std::pair<const int, double> V;
27
    {
28
    typedef std::multimap<int, double> M;
29
    {
30
        typedef M::iterator R;
31
        V ar[] =
32
        {
33
            V(5, 1),
34
            V(5, 2),
35
            V(5, 3),
36
            V(7, 1),
37
            V(7, 2),
38
            V(7, 3),
39
            V(9, 1),
40
            V(9, 2),
41
            V(9, 3)
42
        };
43
        M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
44
        R r = m.upper_bound(4);
45
        assert(r == m.begin());
46
        r = m.upper_bound(5);
47
        assert(r == std::next(m.begin(), 3));
48
        r = m.upper_bound(6);
49
        assert(r == std::next(m.begin(), 3));
50
        r = m.upper_bound(7);
51
        assert(r == std::next(m.begin(), 6));
52
        r = m.upper_bound(8);
53
        assert(r == std::next(m.begin(), 6));
54
        r = m.upper_bound(9);
55
        assert(r == std::next(m.begin(), 9));
56
        r = m.upper_bound(10);
57
        assert(r == m.end());
58
    }
59
    {
60
        typedef M::const_iterator R;
61
        V ar[] =
62
        {
63
            V(5, 1),
64
            V(5, 2),
65
            V(5, 3),
66
            V(7, 1),
67
            V(7, 2),
68
            V(7, 3),
69
            V(9, 1),
70
            V(9, 2),
71
            V(9, 3)
72
        };
73
        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
74
        R r = m.upper_bound(4);
75
        assert(r == m.begin());
76
        r = m.upper_bound(5);
77
        assert(r == std::next(m.begin(), 3));
78
        r = m.upper_bound(6);
79
        assert(r == std::next(m.begin(), 3));
80
        r = m.upper_bound(7);
81
        assert(r == std::next(m.begin(), 6));
82
        r = m.upper_bound(8);
83
        assert(r == std::next(m.begin(), 6));
84
        r = m.upper_bound(9);
85
        assert(r == std::next(m.begin(), 9));
86
        r = m.upper_bound(10);
87
        assert(r == m.end());
88
    }
89
    }
90
#if TEST_STD_VER >= 11
91
    {
92
    typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
93
    {
94
        typedef M::iterator R;
95
        V ar[] =
96
        {
97
            V(5, 1),
98
            V(5, 2),
99
            V(5, 3),
100
            V(7, 1),
101
            V(7, 2),
102
            V(7, 3),
103
            V(9, 1),
104
            V(9, 2),
105
            V(9, 3)
106
        };
107
        M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
108
        R r = m.upper_bound(4);
109
        assert(r == m.begin());
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(10);
121
        assert(r == m.end());
122
    }
123
    {
124
        typedef M::const_iterator R;
125
        V ar[] =
126
        {
127
            V(5, 1),
128
            V(5, 2),
129
            V(5, 3),
130
            V(7, 1),
131
            V(7, 2),
132
            V(7, 3),
133
            V(9, 1),
134
            V(9, 2),
135
            V(9, 3)
136
        };
137
        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
138
        R r = m.upper_bound(4);
139
        assert(r == m.begin());
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(10);
151
        assert(r == m.end());
152
    }
153
    }
154
#endif
155
#if TEST_STD_VER > 11
156
    {
157
    typedef std::multimap<int, double, std::less<>> M;
158
    typedef M::iterator R;
159
    V ar[] =
160
    {
161
        V(5, 1),
162
        V(5, 2),
163
        V(5, 3),
164
        V(7, 1),
165
        V(7, 2),
166
        V(7, 3),
167
        V(9, 1),
168
        V(9, 2),
169
        V(9, 3)
170
    };
171
    M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
172
    R r = m.upper_bound(4);
173
    assert(r == m.begin());
174
    r = m.upper_bound(5);
175
    assert(r == std::next(m.begin(), 3));
176
    r = m.upper_bound(6);
177
    assert(r == std::next(m.begin(), 3));
178
    r = m.upper_bound(7);
179
    assert(r == std::next(m.begin(), 6));
180
    r = m.upper_bound(8);
181
    assert(r == std::next(m.begin(), 6));
182
    r = m.upper_bound(9);
183
    assert(r == std::next(m.begin(), 9));
184
    r = m.upper_bound(10);
185
    assert(r == m.end());
186

187
    r = m.upper_bound(C2Int(4));
188
    assert(r == m.begin());
189
    r = m.upper_bound(C2Int(5));
190
    assert(r == std::next(m.begin(), 3));
191
    r = m.upper_bound(C2Int(6));
192
    assert(r == std::next(m.begin(), 3));
193
    r = m.upper_bound(C2Int(7));
194
    assert(r == std::next(m.begin(), 6));
195
    r = m.upper_bound(C2Int(8));
196
    assert(r == std::next(m.begin(), 6));
197
    r = m.upper_bound(C2Int(9));
198
    assert(r == std::next(m.begin(), 9));
199
    r = m.upper_bound(C2Int(10));
200
    }
201

202
    {
203
    typedef PrivateConstructor PC;
204
    typedef std::multimap<PC, double, std::less<>> M;
205
    typedef M::iterator R;
206

207
    M m;
208
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 ));
209
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 ));
210
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 ));
211
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 ));
212
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 ));
213
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 ));
214
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 ));
215
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 ));
216
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 ));
217

218
    R r = m.upper_bound(4);
219
    assert(r == m.begin());
220
    r = m.upper_bound(5);
221
    assert(r == std::next(m.begin(), 3));
222
    r = m.upper_bound(6);
223
    assert(r == std::next(m.begin(), 3));
224
    r = m.upper_bound(7);
225
    assert(r == std::next(m.begin(), 6));
226
    r = m.upper_bound(8);
227
    assert(r == std::next(m.begin(), 6));
228
    r = m.upper_bound(9);
229
    assert(r == std::next(m.begin(), 9));
230
    r = m.upper_bound(10);
231
    assert(r == m.end());
232
    }
233

234
#endif
235

236
  return 0;
237
}
238