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 begin();
14
// const_iterator begin() const;
15
//       iterator end();
16
// const_iterator end()   const;
17
//
18
//       reverse_iterator rbegin();
19
// const_reverse_iterator rbegin() const;
20
//       reverse_iterator rend();
21
// const_reverse_iterator rend()   const;
22
//
23
// const_iterator         cbegin()  const;
24
// const_iterator         cend()    const;
25
// const_reverse_iterator crbegin() const;
26
// const_reverse_iterator crend()   const;
27

28
#include <set>
29
#include <cassert>
30
#include <cstddef>
31

32
#include "test_macros.h"
33
#include "min_allocator.h"
34

35
int main(int, char**)
36
{
37
    {
38
        typedef int V;
39
        V ar[] =
40
        {
41
            1,
42
            1,
43
            1,
44
            2,
45
            2,
46
            2,
47
            3,
48
            3,
49
            3,
50
            4,
51
            4,
52
            4,
53
            5,
54
            5,
55
            5,
56
            6,
57
            6,
58
            6,
59
            7,
60
            7,
61
            7,
62
            8,
63
            8,
64
            8
65
        };
66
        std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
67
        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
68
        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
69
        std::multiset<int>::iterator i;
70
        i = m.begin();
71
        std::multiset<int>::const_iterator k = i;
72
        assert(i == k);
73
        for (int j = 1; j <= 8; ++j)
74
            for (int n = 0; n < 3; ++n, ++i)
75
                assert(*i == j);
76
        assert(i == m.end());
77
        for (int j = 8; j >= 1; --j)
78
            for (int n = 0; n < 3; ++n) {
79
                --i;
80
                assert(*i == j);
81
            }
82
        assert(i == m.begin());
83
    }
84
    {
85
        typedef int V;
86
        V ar[] =
87
        {
88
            1,
89
            1,
90
            1,
91
            2,
92
            2,
93
            2,
94
            3,
95
            3,
96
            3,
97
            4,
98
            4,
99
            4,
100
            5,
101
            5,
102
            5,
103
            6,
104
            6,
105
            6,
106
            7,
107
            7,
108
            7,
109
            8,
110
            8,
111
            8
112
        };
113
        const std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
114
        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
115
        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
116
        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
117
        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
118
        std::multiset<int>::const_iterator i;
119
        i = m.begin();
120
        for (int j = 1; j <= 8; ++j)
121
            for (int k = 0; k < 3; ++k, ++i)
122
                assert(*i == j);
123
        assert(i == m.end());
124
        for (int j = 8; j >= 1; --j)
125
            for (int k = 0; k < 3; ++k) {
126
                --i;
127
                assert(*i == j);
128
            }
129
        assert(i == m.begin());
130
    }
131
#if TEST_STD_VER >= 11
132
    {
133
        typedef int V;
134
        V ar[] =
135
        {
136
            1,
137
            1,
138
            1,
139
            2,
140
            2,
141
            2,
142
            3,
143
            3,
144
            3,
145
            4,
146
            4,
147
            4,
148
            5,
149
            5,
150
            5,
151
            6,
152
            6,
153
            6,
154
            7,
155
            7,
156
            7,
157
            8,
158
            8,
159
            8
160
        };
161
        std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
162
        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
163
        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
164
        std::multiset<int, std::less<int>, min_allocator<int>>::iterator i;
165
        i = m.begin();
166
        std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
167
        assert(i == k);
168
        for (int j = 1; j <= 8; ++j)
169
            for (int n = 0; n < 3; ++n, ++i)
170
                assert(*i == j);
171
        assert(i == m.end());
172
        for (int j = 8; j >= 1; --j)
173
            for (int n = 0; n < 3; ++n) {
174
                --i;
175
                assert(*i == j);
176
            }
177
        assert(i == m.begin());
178
    }
179
    {
180
        typedef int V;
181
        V ar[] =
182
        {
183
            1,
184
            1,
185
            1,
186
            2,
187
            2,
188
            2,
189
            3,
190
            3,
191
            3,
192
            4,
193
            4,
194
            4,
195
            5,
196
            5,
197
            5,
198
            6,
199
            6,
200
            6,
201
            7,
202
            7,
203
            7,
204
            8,
205
            8,
206
            8
207
        };
208
        const std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
209
        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
210
        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
211
        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
212
        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
213
        std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i;
214
        i = m.begin();
215
        for (int j = 1; j <= 8; ++j)
216
            for (int k = 0; k < 3; ++k, ++i)
217
                assert(*i == j);
218
        assert(i == m.end());
219
        for (int j = 8; j >= 1; --j)
220
            for (int k = 0; k < 3; ++k) {
221
                --i;
222
                assert(*i == j);
223
            }
224
        assert(i == m.begin());
225
    }
226
#endif
227
#if TEST_STD_VER > 11
228
    { // N3644 testing
229
        typedef std::multiset<int> C;
230
        C::iterator ii1{}, ii2{};
231
        C::iterator ii4 = ii1;
232
        C::const_iterator cii{};
233
        assert ( ii1 == ii2 );
234
        assert ( ii1 == ii4 );
235

236
        assert (!(ii1 != ii2 ));
237

238
        assert ( (ii1 == cii ));
239
        assert ( (cii == ii1 ));
240
        assert (!(ii1 != cii ));
241
        assert (!(cii != ii1 ));
242
    }
243
#endif
244

245
  return 0;
246
}
247