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     }
77     {
78         typedef int V;
79         V ar[] =
80         {
81             1,
82             1,
83             1,
84             2,
85             2,
86             2,
87             3,
88             3,
89             3,
90             4,
91             4,
92             4,
93             5,
94             5,
95             5,
96             6,
97             6,
98             6,
99             7,
100             7,
101             7,
102             8,
103             8,
104             8
105         };
106         const std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
107         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
108         assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
109         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
110         assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
111         std::multiset<int>::const_iterator i;
112         i = m.begin();
113         for (int j = 1; j <= 8; ++j)
114             for (int k = 0; k < 3; ++k, ++i)
115                 assert(*i == j);
116     }
117 #if TEST_STD_VER >= 11
118     {
119         typedef int V;
120         V ar[] =
121         {
122             1,
123             1,
124             1,
125             2,
126             2,
127             2,
128             3,
129             3,
130             3,
131             4,
132             4,
133             4,
134             5,
135             5,
136             5,
137             6,
138             6,
139             6,
140             7,
141             7,
142             7,
143             8,
144             8,
145             8
146         };
147         std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
148         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
149         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
150         std::multiset<int, std::less<int>, min_allocator<int>>::iterator i;
151         i = m.begin();
152         std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
153         assert(i == k);
154         for (int j = 1; j <= 8; ++j)
155             for (int n = 0; n < 3; ++n, ++i)
156                 assert(*i == j);
157     }
158     {
159         typedef int V;
160         V ar[] =
161         {
162             1,
163             1,
164             1,
165             2,
166             2,
167             2,
168             3,
169             3,
170             3,
171             4,
172             4,
173             4,
174             5,
175             5,
176             5,
177             6,
178             6,
179             6,
180             7,
181             7,
182             7,
183             8,
184             8,
185             8
186         };
187         const std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
188         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
189         assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
190         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
191         assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
192         std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i;
193         i = m.begin();
194         for (int j = 1; j <= 8; ++j)
195             for (int k = 0; k < 3; ++k, ++i)
196                 assert(*i == j);
197     }
198 #endif
199 #if TEST_STD_VER > 11
200     { // N3644 testing
201         typedef std::multiset<int> C;
202         C::iterator ii1{}, ii2{};
203         C::iterator ii4 = ii1;
204         C::const_iterator cii{};
205         assert ( ii1 == ii2 );
206         assert ( ii1 == ii4 );
207 
208         assert (!(ii1 != ii2 ));
209 
210         assert ( (ii1 == cii ));
211         assert ( (cii == ii1 ));
212         assert (!(ii1 != cii ));
213         assert (!(cii != ii1 ));
214     }
215 #endif
216 
217   return 0;
218 }
219