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