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 // template <class Key, class T, class Compare, class Allocator>
15 // void
16 // swap(multimap<Key, T, Compare, Allocator>& x, multimap<Key, T, Compare, Allocator>& y);
17
18 #include <map>
19 #include <cassert>
20 #include "test_allocator.h"
21 #include "../../../test_compare.h"
22 #include "min_allocator.h"
23
main()24 int main()
25 {
26 typedef std::pair<const int, double> V;
27 {
28 typedef std::multimap<int, double> M;
29 {
30 V ar1[] =
31 {
32 };
33 V ar2[] =
34 {
35 };
36 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
37 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
38 M m1_save = m1;
39 M m2_save = m2;
40 swap(m1, m2);
41 assert(m1 == m2_save);
42 assert(m2 == m1_save);
43 }
44 {
45 V ar1[] =
46 {
47 };
48 V ar2[] =
49 {
50 V(5, 5),
51 V(6, 6),
52 V(7, 7),
53 V(8, 8),
54 V(9, 9),
55 V(10, 10),
56 V(11, 11),
57 V(12, 12)
58 };
59 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
60 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
61 M m1_save = m1;
62 M m2_save = m2;
63 swap(m1, m2);
64 assert(m1 == m2_save);
65 assert(m2 == m1_save);
66 }
67 {
68 V ar1[] =
69 {
70 V(1, 1),
71 V(2, 2),
72 V(3, 3),
73 V(4, 4)
74 };
75 V ar2[] =
76 {
77 };
78 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
79 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
80 M m1_save = m1;
81 M m2_save = m2;
82 swap(m1, m2);
83 assert(m1 == m2_save);
84 assert(m2 == m1_save);
85 }
86 {
87 V ar1[] =
88 {
89 V(1, 1),
90 V(2, 2),
91 V(3, 3),
92 V(4, 4)
93 };
94 V ar2[] =
95 {
96 V(5, 5),
97 V(6, 6),
98 V(7, 7),
99 V(8, 8),
100 V(9, 9),
101 V(10, 10),
102 V(11, 11),
103 V(12, 12)
104 };
105 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
106 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
107 M m1_save = m1;
108 M m2_save = m2;
109 swap(m1, m2);
110 assert(m1 == m2_save);
111 assert(m2 == m1_save);
112 }
113 {
114 typedef test_allocator<V> A;
115 typedef test_compare<std::less<int> > C;
116 typedef std::multimap<int, double, C, A> M;
117 V ar1[] =
118 {
119 V(1, 1),
120 V(2, 2),
121 V(3, 3),
122 V(4, 4)
123 };
124 V ar2[] =
125 {
126 V(5, 5),
127 V(6, 6),
128 V(7, 7),
129 V(8, 8),
130 V(9, 9),
131 V(10, 10),
132 V(11, 11),
133 V(12, 12)
134 };
135 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1));
136 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2));
137 M m1_save = m1;
138 M m2_save = m2;
139 swap(m1, m2);
140 assert(m1 == m2_save);
141 assert(m2 == m1_save);
142 assert(m1.key_comp() == C(2));
143 assert(m1.get_allocator() == A(1));
144 assert(m2.key_comp() == C(1));
145 assert(m2.get_allocator() == A(2));
146 }
147 {
148 typedef other_allocator<V> A;
149 typedef test_compare<std::less<int> > C;
150 typedef std::multimap<int, double, C, A> M;
151 V ar1[] =
152 {
153 V(1, 1),
154 V(2, 2),
155 V(3, 3),
156 V(4, 4)
157 };
158 V ar2[] =
159 {
160 V(5, 5),
161 V(6, 6),
162 V(7, 7),
163 V(8, 8),
164 V(9, 9),
165 V(10, 10),
166 V(11, 11),
167 V(12, 12)
168 };
169 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1));
170 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2));
171 M m1_save = m1;
172 M m2_save = m2;
173 swap(m1, m2);
174 assert(m1 == m2_save);
175 assert(m2 == m1_save);
176 assert(m1.key_comp() == C(2));
177 assert(m1.get_allocator() == A(2));
178 assert(m2.key_comp() == C(1));
179 assert(m2.get_allocator() == A(1));
180 }
181 }
182 #if __cplusplus >= 201103L
183 {
184 typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
185 {
186 V ar1[] =
187 {
188 };
189 V ar2[] =
190 {
191 };
192 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
193 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
194 M m1_save = m1;
195 M m2_save = m2;
196 swap(m1, m2);
197 assert(m1 == m2_save);
198 assert(m2 == m1_save);
199 }
200 {
201 V ar1[] =
202 {
203 };
204 V ar2[] =
205 {
206 V(5, 5),
207 V(6, 6),
208 V(7, 7),
209 V(8, 8),
210 V(9, 9),
211 V(10, 10),
212 V(11, 11),
213 V(12, 12)
214 };
215 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
216 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
217 M m1_save = m1;
218 M m2_save = m2;
219 swap(m1, m2);
220 assert(m1 == m2_save);
221 assert(m2 == m1_save);
222 }
223 {
224 V ar1[] =
225 {
226 V(1, 1),
227 V(2, 2),
228 V(3, 3),
229 V(4, 4)
230 };
231 V ar2[] =
232 {
233 };
234 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
235 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
236 M m1_save = m1;
237 M m2_save = m2;
238 swap(m1, m2);
239 assert(m1 == m2_save);
240 assert(m2 == m1_save);
241 }
242 {
243 V ar1[] =
244 {
245 V(1, 1),
246 V(2, 2),
247 V(3, 3),
248 V(4, 4)
249 };
250 V ar2[] =
251 {
252 V(5, 5),
253 V(6, 6),
254 V(7, 7),
255 V(8, 8),
256 V(9, 9),
257 V(10, 10),
258 V(11, 11),
259 V(12, 12)
260 };
261 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
262 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
263 M m1_save = m1;
264 M m2_save = m2;
265 swap(m1, m2);
266 assert(m1 == m2_save);
267 assert(m2 == m1_save);
268 }
269 {
270 typedef min_allocator<V> A;
271 typedef test_compare<std::less<int> > C;
272 typedef std::multimap<int, double, C, A> M;
273 V ar1[] =
274 {
275 V(1, 1),
276 V(2, 2),
277 V(3, 3),
278 V(4, 4)
279 };
280 V ar2[] =
281 {
282 V(5, 5),
283 V(6, 6),
284 V(7, 7),
285 V(8, 8),
286 V(9, 9),
287 V(10, 10),
288 V(11, 11),
289 V(12, 12)
290 };
291 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A());
292 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A());
293 M m1_save = m1;
294 M m2_save = m2;
295 swap(m1, m2);
296 assert(m1 == m2_save);
297 assert(m2 == m1_save);
298 assert(m1.key_comp() == C(2));
299 assert(m1.get_allocator() == A());
300 assert(m2.key_comp() == C(1));
301 assert(m2.get_allocator() == A());
302 }
303 }
304 #endif
305 }
306