1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <map>
11 
12 // class multimap
13 
14 // pair<iterator, iterator>             equal_range(const key_type& k);
15 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
16 
17 #include <map>
18 #include <cassert>
19 
20 #include "min_allocator.h"
21 #include "private_constructor.hpp"
22 
23 int main()
24 {
25     typedef std::pair<const int, double> V;
26     {
27     typedef std::multimap<int, double> M;
28     {
29         typedef std::pair<M::iterator, M::iterator> R;
30         V ar[] =
31         {
32             V(5, 1),
33             V(5, 2),
34             V(5, 3),
35             V(7, 1),
36             V(7, 2),
37             V(7, 3),
38             V(9, 1),
39             V(9, 2),
40             V(9, 3)
41         };
42         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
43         R r = m.equal_range(4);
44         assert(r.first == m.begin());
45         assert(r.second == m.begin());
46         r = m.equal_range(5);
47         assert(r.first == m.begin());
48         assert(r.second == next(m.begin(), 3));
49         r = m.equal_range(6);
50         assert(r.first == next(m.begin(), 3));
51         assert(r.second == next(m.begin(), 3));
52         r = m.equal_range(7);
53         assert(r.first == next(m.begin(), 3));
54         assert(r.second == next(m.begin(), 6));
55         r = m.equal_range(8);
56         assert(r.first == next(m.begin(), 6));
57         assert(r.second == next(m.begin(), 6));
58         r = m.equal_range(9);
59         assert(r.first == next(m.begin(), 6));
60         assert(r.second == next(m.begin(), 9));
61         r = m.equal_range(10);
62         assert(r.first == m.end());
63         assert(r.second == m.end());
64     }
65     {
66         typedef std::pair<M::const_iterator, M::const_iterator> R;
67         V ar[] =
68         {
69             V(5, 1),
70             V(5, 2),
71             V(5, 3),
72             V(7, 1),
73             V(7, 2),
74             V(7, 3),
75             V(9, 1),
76             V(9, 2),
77             V(9, 3)
78         };
79         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
80         R r = m.equal_range(4);
81         assert(r.first == m.begin());
82         assert(r.second == m.begin());
83         r = m.equal_range(5);
84         assert(r.first == m.begin());
85         assert(r.second == next(m.begin(), 3));
86         r = m.equal_range(6);
87         assert(r.first == next(m.begin(), 3));
88         assert(r.second == next(m.begin(), 3));
89         r = m.equal_range(7);
90         assert(r.first == next(m.begin(), 3));
91         assert(r.second == next(m.begin(), 6));
92         r = m.equal_range(8);
93         assert(r.first == next(m.begin(), 6));
94         assert(r.second == next(m.begin(), 6));
95         r = m.equal_range(9);
96         assert(r.first == next(m.begin(), 6));
97         assert(r.second == next(m.begin(), 9));
98         r = m.equal_range(10);
99         assert(r.first == m.end());
100         assert(r.second == m.end());
101     }
102     }
103 #if __cplusplus >= 201103L
104     {
105     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
106     {
107         typedef std::pair<M::iterator, M::iterator> R;
108         V ar[] =
109         {
110             V(5, 1),
111             V(5, 2),
112             V(5, 3),
113             V(7, 1),
114             V(7, 2),
115             V(7, 3),
116             V(9, 1),
117             V(9, 2),
118             V(9, 3)
119         };
120         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
121         R r = m.equal_range(4);
122         assert(r.first == m.begin());
123         assert(r.second == m.begin());
124         r = m.equal_range(5);
125         assert(r.first == m.begin());
126         assert(r.second == next(m.begin(), 3));
127         r = m.equal_range(6);
128         assert(r.first == next(m.begin(), 3));
129         assert(r.second == next(m.begin(), 3));
130         r = m.equal_range(7);
131         assert(r.first == next(m.begin(), 3));
132         assert(r.second == next(m.begin(), 6));
133         r = m.equal_range(8);
134         assert(r.first == next(m.begin(), 6));
135         assert(r.second == next(m.begin(), 6));
136         r = m.equal_range(9);
137         assert(r.first == next(m.begin(), 6));
138         assert(r.second == next(m.begin(), 9));
139         r = m.equal_range(10);
140         assert(r.first == m.end());
141         assert(r.second == m.end());
142     }
143     {
144         typedef std::pair<M::const_iterator, M::const_iterator> R;
145         V ar[] =
146         {
147             V(5, 1),
148             V(5, 2),
149             V(5, 3),
150             V(7, 1),
151             V(7, 2),
152             V(7, 3),
153             V(9, 1),
154             V(9, 2),
155             V(9, 3)
156         };
157         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
158         R r = m.equal_range(4);
159         assert(r.first == m.begin());
160         assert(r.second == m.begin());
161         r = m.equal_range(5);
162         assert(r.first == m.begin());
163         assert(r.second == next(m.begin(), 3));
164         r = m.equal_range(6);
165         assert(r.first == next(m.begin(), 3));
166         assert(r.second == next(m.begin(), 3));
167         r = m.equal_range(7);
168         assert(r.first == next(m.begin(), 3));
169         assert(r.second == next(m.begin(), 6));
170         r = m.equal_range(8);
171         assert(r.first == next(m.begin(), 6));
172         assert(r.second == next(m.begin(), 6));
173         r = m.equal_range(9);
174         assert(r.first == next(m.begin(), 6));
175         assert(r.second == next(m.begin(), 9));
176         r = m.equal_range(10);
177         assert(r.first == m.end());
178         assert(r.second == m.end());
179     }
180     }
181 #endif
182 #if _LIBCPP_STD_VER > 11
183     {
184     typedef std::pair<const int, double> V;
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 == next(m.begin(), 3));
207     r = m.equal_range(6);
208     assert(r.first == next(m.begin(), 3));
209     assert(r.second == next(m.begin(), 3));
210     r = m.equal_range(7);
211     assert(r.first == next(m.begin(), 3));
212     assert(r.second == next(m.begin(), 6));
213     r = m.equal_range(8);
214     assert(r.first == next(m.begin(), 6));
215     assert(r.second == next(m.begin(), 6));
216     r = m.equal_range(9);
217     assert(r.first == next(m.begin(), 6));
218     assert(r.second == next(m.begin(), 9));
219     r = m.equal_range(10);
220     assert(r.first == m.end());
221     assert(r.second == m.end());
222     }
223 
224     {
225     typedef PrivateConstructor PC;
226     typedef std::multimap<PC, double, std::less<>> M;
227     typedef std::pair<M::iterator, M::iterator> R;
228 
229     M m;
230     m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 ));
231     m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 ));
232     m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 ));
233     m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 ));
234     m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 ));
235     m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 ));
236     m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 ));
237     m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 ));
238     m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 ));
239 
240 //  assert(m.size() == 9);
241     R r = m.equal_range(4);
242     assert(r.first == m.begin());
243     assert(r.second == m.begin());
244     r = m.equal_range(5);
245     assert(r.first == m.begin());
246     assert(r.second == next(m.begin(), 3));
247     r = m.equal_range(6);
248     assert(r.first == next(m.begin(), 3));
249     assert(r.second == next(m.begin(), 3));
250     r = m.equal_range(7);
251     assert(r.first == next(m.begin(), 3));
252     assert(r.second == next(m.begin(), 6));
253     r = m.equal_range(8);
254     assert(r.first == next(m.begin(), 6));
255     assert(r.second == next(m.begin(), 6));
256     r = m.equal_range(9);
257     assert(r.first == next(m.begin(), 6));
258     assert(r.second == next(m.begin(), 9));
259     r = m.equal_range(10);
260     assert(r.first == m.end());
261     assert(r.second == m.end());
262     }
263 #endif
264 }
265