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

11
// class multimap
12

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

187
    typedef std::pair<M::iterator, M::iterator> R;
188
    V ar[] =
189
    {
190
        V(5, 1),
191
        V(5, 2),
192
        V(5, 3),
193
        V(7, 1),
194
        V(7, 2),
195
        V(7, 3),
196
        V(9, 1),
197
        V(9, 2),
198
        V(9, 3)
199
    };
200
    M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
201
    R r = m.equal_range(4);
202
    assert(r.first == m.begin());
203
    assert(r.second == m.begin());
204
    r = m.equal_range(5);
205
    assert(r.first == m.begin());
206
    assert(r.second == std::next(m.begin(), 3));
207
    r = m.equal_range(6);
208
    assert(r.first == std::next(m.begin(), 3));
209
    assert(r.second == std::next(m.begin(), 3));
210
    r = m.equal_range(7);
211
    assert(r.first == std::next(m.begin(), 3));
212
    assert(r.second == std::next(m.begin(), 6));
213
    r = m.equal_range(8);
214
    assert(r.first == std::next(m.begin(), 6));
215
    assert(r.second == std::next(m.begin(), 6));
216
    r = m.equal_range(9);
217
    assert(r.first == std::next(m.begin(), 6));
218
    assert(r.second == std::next(m.begin(), 9));
219
    r = m.equal_range(10);
220
    assert(r.first == m.end());
221
    assert(r.second == m.end());
222

223
    r = m.equal_range(C2Int(4));
224
    assert(r.first == m.begin());
225
    assert(r.second == m.begin());
226
    r = m.equal_range(C2Int(5));
227
    assert(r.first == m.begin());
228
    assert(r.second == std::next(m.begin(), 3));
229
    r = m.equal_range(C2Int(6));
230
    assert(r.first == std::next(m.begin(), 3));
231
    assert(r.second == std::next(m.begin(), 3));
232
    r = m.equal_range(C2Int(7));
233
    assert(r.first == std::next(m.begin(), 3));
234
    assert(r.second == std::next(m.begin(), 6));
235
    r = m.equal_range(C2Int(8));
236
    assert(r.first == std::next(m.begin(), 6));
237
    assert(r.second == std::next(m.begin(), 6));
238
    r = m.equal_range(C2Int(9));
239
    assert(r.first == std::next(m.begin(), 6));
240
    assert(r.second == std::next(m.begin(), 9));
241
    r = m.equal_range(C2Int(10));
242
    assert(r.first == m.end());
243
    assert(r.second == m.end());
244
    }
245

246
    {
247
    typedef PrivateConstructor PC;
248
    typedef std::multimap<PC, double, std::less<>> M;
249
    typedef std::pair<M::iterator, M::iterator> R;
250

251
    M m;
252
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 ));
253
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 ));
254
    m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 ));
255
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 ));
256
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 ));
257
    m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 ));
258
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 ));
259
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 ));
260
    m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 ));
261

262
//  assert(m.size() == 9);
263
    R r = m.equal_range(4);
264
    assert(r.first == m.begin());
265
    assert(r.second == m.begin());
266
    r = m.equal_range(5);
267
    assert(r.first == m.begin());
268
    assert(r.second == std::next(m.begin(), 3));
269
    r = m.equal_range(6);
270
    assert(r.first == std::next(m.begin(), 3));
271
    assert(r.second == std::next(m.begin(), 3));
272
    r = m.equal_range(7);
273
    assert(r.first == std::next(m.begin(), 3));
274
    assert(r.second == std::next(m.begin(), 6));
275
    r = m.equal_range(8);
276
    assert(r.first == std::next(m.begin(), 6));
277
    assert(r.second == std::next(m.begin(), 6));
278
    r = m.equal_range(9);
279
    assert(r.first == std::next(m.begin(), 6));
280
    assert(r.second == std::next(m.begin(), 9));
281
    r = m.equal_range(10);
282
    assert(r.first == m.end());
283
    assert(r.second == m.end());
284
    }
285
#endif
286

287
  return 0;
288
}
289