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