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 //       iterator upper_bound(const key_type& k);
15 // const_iterator upper_bound(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 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.upper_bound(4);
44         assert(r == m.begin());
45         r = m.upper_bound(5);
46         assert(r == next(m.begin(), 3));
47         r = m.upper_bound(6);
48         assert(r == next(m.begin(), 3));
49         r = m.upper_bound(7);
50         assert(r == next(m.begin(), 6));
51         r = m.upper_bound(8);
52         assert(r == next(m.begin(), 6));
53         r = m.upper_bound(9);
54         assert(r == next(m.begin(), 9));
55         r = m.upper_bound(10);
56         assert(r == m.end());
57     }
58     {
59         typedef M::const_iterator R;
60         V ar[] =
61         {
62             V(5, 1),
63             V(5, 2),
64             V(5, 3),
65             V(7, 1),
66             V(7, 2),
67             V(7, 3),
68             V(9, 1),
69             V(9, 2),
70             V(9, 3)
71         };
72         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
73         R r = m.upper_bound(4);
74         assert(r == m.begin());
75         r = m.upper_bound(5);
76         assert(r == next(m.begin(), 3));
77         r = m.upper_bound(6);
78         assert(r == next(m.begin(), 3));
79         r = m.upper_bound(7);
80         assert(r == next(m.begin(), 6));
81         r = m.upper_bound(8);
82         assert(r == next(m.begin(), 6));
83         r = m.upper_bound(9);
84         assert(r == next(m.begin(), 9));
85         r = m.upper_bound(10);
86         assert(r == m.end());
87     }
88     }
89 #if __cplusplus >= 201103L
90     {
91     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
92     {
93         typedef M::iterator R;
94         V ar[] =
95         {
96             V(5, 1),
97             V(5, 2),
98             V(5, 3),
99             V(7, 1),
100             V(7, 2),
101             V(7, 3),
102             V(9, 1),
103             V(9, 2),
104             V(9, 3)
105         };
106         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
107         R r = m.upper_bound(4);
108         assert(r == m.begin());
109         r = m.upper_bound(5);
110         assert(r == next(m.begin(), 3));
111         r = m.upper_bound(6);
112         assert(r == next(m.begin(), 3));
113         r = m.upper_bound(7);
114         assert(r == next(m.begin(), 6));
115         r = m.upper_bound(8);
116         assert(r == next(m.begin(), 6));
117         r = m.upper_bound(9);
118         assert(r == next(m.begin(), 9));
119         r = m.upper_bound(10);
120         assert(r == m.end());
121     }
122     {
123         typedef M::const_iterator R;
124         V ar[] =
125         {
126             V(5, 1),
127             V(5, 2),
128             V(5, 3),
129             V(7, 1),
130             V(7, 2),
131             V(7, 3),
132             V(9, 1),
133             V(9, 2),
134             V(9, 3)
135         };
136         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
137         R r = m.upper_bound(4);
138         assert(r == m.begin());
139         r = m.upper_bound(5);
140         assert(r == next(m.begin(), 3));
141         r = m.upper_bound(6);
142         assert(r == next(m.begin(), 3));
143         r = m.upper_bound(7);
144         assert(r == next(m.begin(), 6));
145         r = m.upper_bound(8);
146         assert(r == next(m.begin(), 6));
147         r = m.upper_bound(9);
148         assert(r == next(m.begin(), 9));
149         r = m.upper_bound(10);
150         assert(r == m.end());
151     }
152     }
153 #endif
154 #if _LIBCPP_STD_VER > 11
155     {
156     typedef std::pair<const int, double> V;
157     typedef std::multimap<int, double, std::less<>> M;
158     typedef M::iterator R;
159     V ar[] =
160     {
161         V(5, 1),
162         V(5, 2),
163         V(5, 3),
164         V(7, 1),
165         V(7, 2),
166         V(7, 3),
167         V(9, 1),
168         V(9, 2),
169         V(9, 3)
170     };
171     M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
172     R r = m.upper_bound(4);
173     assert(r == m.begin());
174     r = m.upper_bound(5);
175     assert(r == next(m.begin(), 3));
176     r = m.upper_bound(6);
177     assert(r == next(m.begin(), 3));
178     r = m.upper_bound(7);
179     assert(r == next(m.begin(), 6));
180     r = m.upper_bound(8);
181     assert(r == next(m.begin(), 6));
182     r = m.upper_bound(9);
183     assert(r == next(m.begin(), 9));
184     r = m.upper_bound(10);
185     assert(r == m.end());
186     }
187 
188     {
189     typedef PrivateConstructor PC;
190     typedef std::multimap<PC, double, std::less<>> M;
191     typedef M::iterator R;
192 
193     M m;
194     m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 ));
195     m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 ));
196     m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 ));
197     m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 ));
198     m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 ));
199     m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 ));
200     m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 ));
201     m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 ));
202     m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 ));
203 
204     R r = m.upper_bound(4);
205     assert(r == m.begin());
206     r = m.upper_bound(5);
207     assert(r == next(m.begin(), 3));
208     r = m.upper_bound(6);
209     assert(r == next(m.begin(), 3));
210     r = m.upper_bound(7);
211     assert(r == next(m.begin(), 6));
212     r = m.upper_bound(8);
213     assert(r == next(m.begin(), 6));
214     r = m.upper_bound(9);
215     assert(r == next(m.begin(), 9));
216     r = m.upper_bound(10);
217     assert(r == m.end());
218     }
219 
220 #endif
221 }
222