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 map
12

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

174
    V ar[] =
175
    {
176
        V(5, 5),
177
        V(6, 6),
178
        V(7, 7),
179
        V(8, 8),
180
        V(9, 9),
181
        V(10, 10),
182
        V(11, 11),
183
        V(12, 12)
184
    };
185
    M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
186
    R r = m.find(5);
187
    assert(r == m.begin());
188
    r = m.find(6);
189
    assert(r == std::next(m.begin()));
190
    r = m.find(7);
191
    assert(r == std::next(m.begin(), 2));
192
    r = m.find(8);
193
    assert(r == std::next(m.begin(), 3));
194
    r = m.find(9);
195
    assert(r == std::next(m.begin(), 4));
196
    r = m.find(10);
197
    assert(r == std::next(m.begin(), 5));
198
    r = m.find(11);
199
    assert(r == std::next(m.begin(), 6));
200
    r = m.find(12);
201
    assert(r == std::next(m.begin(), 7));
202
    r = m.find(4);
203
    assert(r == std::next(m.begin(), 8));
204

205
    r = m.find(C2Int(5));
206
    assert(r == m.begin());
207
    r = m.find(C2Int(6));
208
    assert(r == std::next(m.begin()));
209
    r = m.find(C2Int(7));
210
    assert(r == std::next(m.begin(), 2));
211
    r = m.find(C2Int(8));
212
    assert(r == std::next(m.begin(), 3));
213
    r = m.find(C2Int(9));
214
    assert(r == std::next(m.begin(), 4));
215
    r = m.find(C2Int(10));
216
    assert(r == std::next(m.begin(), 5));
217
    r = m.find(C2Int(11));
218
    assert(r == std::next(m.begin(), 6));
219
    r = m.find(C2Int(12));
220
    assert(r == std::next(m.begin(), 7));
221
    r = m.find(C2Int(4));
222
    assert(r == std::next(m.begin(), 8));
223
    }
224

225
    {
226
    typedef PrivateConstructor PC;
227
    typedef std::map<PC, double, std::less<>> M;
228
    typedef M::iterator R;
229

230
    M m;
231
    m [ PC::make(5)  ] = 5;
232
    m [ PC::make(6)  ] = 6;
233
    m [ PC::make(7)  ] = 7;
234
    m [ PC::make(8)  ] = 8;
235
    m [ PC::make(9)  ] = 9;
236
    m [ PC::make(10) ] = 10;
237
    m [ PC::make(11) ] = 11;
238
    m [ PC::make(12) ] = 12;
239

240
    R r = m.find(5);
241
    assert(r == m.begin());
242
    r = m.find(6);
243
    assert(r == std::next(m.begin()));
244
    r = m.find(7);
245
    assert(r == std::next(m.begin(), 2));
246
    r = m.find(8);
247
    assert(r == std::next(m.begin(), 3));
248
    r = m.find(9);
249
    assert(r == std::next(m.begin(), 4));
250
    r = m.find(10);
251
    assert(r == std::next(m.begin(), 5));
252
    r = m.find(11);
253
    assert(r == std::next(m.begin(), 6));
254
    r = m.find(12);
255
    assert(r == std::next(m.begin(), 7));
256
    r = m.find(4);
257
    assert(r == std::next(m.begin(), 8));
258
    }
259
#endif
260

261
  return 0;
262
}
263