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// <unordered_map>
10
11// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
12// class Alloc = allocator<pair<const Key, T>>>
13// class unordered_multimap
14
15// void swap(unordered_multimap& __u);
16
17#include <unordered_map>
18#include <string>
19#include <set>
20#include <cassert>
21#include <cstddef>
22#include <iterator>
23
24#include "test_macros.h"
25#include "../../test_compare.h"
26#include "../../test_hash.h"
27#include "test_allocator.h"
28
29#include "min_allocator.h"
30
31int main(int, char**)
32{
33 {
34 typedef test_hash<int> Hash;
35 typedef test_equal_to<int> Compare;
36 typedef test_allocator<std::pair<const int, std::string> > Alloc;
37 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
38 C c1(0, Hash(1), Compare(1), Alloc(1, 1));
39 C c2(0, Hash(2), Compare(2), Alloc(1, 2));
40 c2.max_load_factor(z: 2);
41 c1.swap(c2);
42
43 LIBCPP_ASSERT(c1.bucket_count() == 0);
44 assert(c1.size() == 0);
45 assert(c1.hash_function() == Hash(2));
46 assert(c1.key_eq() == Compare(2));
47 assert(c1.get_allocator().get_id() == 1);
48 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
49 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
50 assert(c1.max_load_factor() == 2);
51
52 LIBCPP_ASSERT(c2.bucket_count() == 0);
53 assert(c2.size() == 0);
54 assert(c2.hash_function() == Hash(1));
55 assert(c2.key_eq() == Compare(1));
56 assert(c2.get_allocator().get_id() == 2);
57 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
58 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
59 assert(c2.max_load_factor() == 1);
60 }
61 {
62 typedef test_hash<int> Hash;
63 typedef test_equal_to<int> Compare;
64 typedef test_allocator<std::pair<const int, std::string> > Alloc;
65 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
66 typedef std::pair<int, std::string> P;
67 P a2[] =
68 {
69 P(10, "ten"),
70 P(20, "twenty"),
71 P(30, "thirty"),
72 P(40, "forty"),
73 P(50, "fifty"),
74 P(60, "sixty"),
75 P(70, "seventy"),
76 P(80, "eighty"),
77 };
78 C c1(0, Hash(1), Compare(1), Alloc(1, 1));
79 C c2(std::begin(arr&: a2), std::end(arr&: a2), 0, Hash(2), Compare(2), Alloc(1, 2));
80 c2.max_load_factor(z: 2);
81 c1.swap(x&: c2);
82
83 assert(c1.bucket_count() >= 8);
84 assert(c1.size() == 8);
85 assert(c1.find(10)->second == "ten");
86 assert(c1.find(20)->second == "twenty");
87 assert(c1.find(30)->second == "thirty");
88 assert(c1.find(40)->second == "forty");
89 assert(c1.find(50)->second == "fifty");
90 assert(c1.find(60)->second == "sixty");
91 assert(c1.find(70)->second == "seventy");
92 assert(c1.find(80)->second == "eighty");
93 assert(c1.hash_function() == Hash(2));
94 assert(c1.key_eq() == Compare(2));
95 assert(c1.get_allocator().get_id() == 1);
96 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
97 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
98 assert(c1.max_load_factor() == 2);
99
100 LIBCPP_ASSERT(c2.bucket_count() == 0);
101 assert(c2.size() == 0);
102 assert(c2.hash_function() == Hash(1));
103 assert(c2.key_eq() == Compare(1));
104 assert(c2.get_allocator().get_id() == 2);
105 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
106 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
107 assert(c2.max_load_factor() == 1);
108 }
109 {
110 typedef test_hash<int> Hash;
111 typedef test_equal_to<int> Compare;
112 typedef test_allocator<std::pair<const int, std::string> > Alloc;
113 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
114 typedef std::pair<int, std::string> P;
115 P a1[] =
116 {
117 P(1, "one"),
118 P(2, "two"),
119 P(3, "three"),
120 P(4, "four"),
121 P(1, "four"),
122 P(2, "four"),
123 };
124 C c1(std::begin(arr&: a1), std::end(arr&: a1), 0, Hash(1), Compare(1), Alloc(1, 1));
125 C c2(0, Hash(2), Compare(2), Alloc(1, 2));
126 c2.max_load_factor(z: 2);
127 c1.swap(x&: c2);
128
129 LIBCPP_ASSERT(c1.bucket_count() == 0);
130 assert(c1.size() == 0);
131 assert(c1.hash_function() == Hash(2));
132 assert(c1.key_eq() == Compare(2));
133 assert(c1.get_allocator().get_id() == 1);
134 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
135 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
136 assert(c1.max_load_factor() == 2);
137
138 assert(c2.bucket_count() >= 6);
139 assert(c2.size() == 6);
140 {
141 std::set<std::string> s;
142 s.insert(x: "one");
143 s.insert(x: "four");
144 assert(s.find(c2.find(1)->second) != s.end());
145 s.erase(position: s.find(x: c2.find(x: 1)->second));
146 assert(s.find(std::next(c2.find(1))->second) != s.end());
147 }
148 {
149 std::set<std::string> s;
150 s.insert(x: "two");
151 s.insert(x: "four");
152 assert(s.find(c2.find(2)->second) != s.end());
153 s.erase(position: s.find(x: c2.find(x: 2)->second));
154 assert(s.find(std::next(c2.find(2))->second) != s.end());
155 }
156 assert(c2.find(3)->second == "three");
157 assert(c2.find(4)->second == "four");
158 assert(c2.hash_function() == Hash(1));
159 assert(c2.key_eq() == Compare(1));
160 assert(c2.get_allocator().get_id() == 2);
161 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
162 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
163 assert(c2.max_load_factor() == 1);
164 }
165 {
166 typedef test_hash<int> Hash;
167 typedef test_equal_to<int> Compare;
168 typedef test_allocator<std::pair<const int, std::string> > Alloc;
169 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
170 typedef std::pair<int, std::string> P;
171 P a1[] =
172 {
173 P(1, "one"),
174 P(2, "two"),
175 P(3, "three"),
176 P(4, "four"),
177 P(1, "four"),
178 P(2, "four"),
179 };
180 P a2[] =
181 {
182 P(10, "ten"),
183 P(20, "twenty"),
184 P(30, "thirty"),
185 P(40, "forty"),
186 P(50, "fifty"),
187 P(60, "sixty"),
188 P(70, "seventy"),
189 P(80, "eighty"),
190 };
191 C c1(std::begin(arr&: a1), std::end(arr&: a1), 0, Hash(1), Compare(1), Alloc(1, 1));
192 C c2(std::begin(arr&: a2), std::end(arr&: a2), 0, Hash(2), Compare(2), Alloc(1, 2));
193 c2.max_load_factor(z: 2);
194 c1.swap(x&: c2);
195
196 assert(c1.bucket_count() >= 8);
197 assert(c1.size() == 8);
198 assert(c1.find(10)->second == "ten");
199 assert(c1.find(20)->second == "twenty");
200 assert(c1.find(30)->second == "thirty");
201 assert(c1.find(40)->second == "forty");
202 assert(c1.find(50)->second == "fifty");
203 assert(c1.find(60)->second == "sixty");
204 assert(c1.find(70)->second == "seventy");
205 assert(c1.find(80)->second == "eighty");
206 assert(c1.hash_function() == Hash(2));
207 assert(c1.key_eq() == Compare(2));
208 assert(c1.get_allocator().get_id() == 1);
209 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
210 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
211 assert(c1.max_load_factor() == 2);
212
213 assert(c2.bucket_count() >= 6);
214 assert(c2.size() == 6);
215 {
216 std::set<std::string> s;
217 s.insert(x: "one");
218 s.insert(x: "four");
219 assert(s.find(c2.find(1)->second) != s.end());
220 s.erase(position: s.find(x: c2.find(x: 1)->second));
221 assert(s.find(std::next(c2.find(1))->second) != s.end());
222 }
223 {
224 std::set<std::string> s;
225 s.insert(x: "two");
226 s.insert(x: "four");
227 assert(s.find(c2.find(2)->second) != s.end());
228 s.erase(position: s.find(x: c2.find(x: 2)->second));
229 assert(s.find(std::next(c2.find(2))->second) != s.end());
230 }
231 assert(c2.find(3)->second == "three");
232 assert(c2.find(4)->second == "four");
233 assert(c2.hash_function() == Hash(1));
234 assert(c2.key_eq() == Compare(1));
235 assert(c2.get_allocator().get_id() == 2);
236 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
237 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
238 assert(c2.max_load_factor() == 1);
239 }
240
241 {
242 typedef test_hash<int> Hash;
243 typedef test_equal_to<int> Compare;
244 typedef other_allocator<std::pair<const int, std::string> > Alloc;
245 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
246 C c1(0, Hash(1), Compare(1), Alloc(1));
247 C c2(0, Hash(2), Compare(2), Alloc(2));
248 c2.max_load_factor(z: 2);
249 c1.swap(x&: c2);
250
251 LIBCPP_ASSERT(c1.bucket_count() == 0);
252 assert(c1.size() == 0);
253 assert(c1.hash_function() == Hash(2));
254 assert(c1.key_eq() == Compare(2));
255 assert(c1.get_allocator() == Alloc(2));
256 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
257 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
258 assert(c1.max_load_factor() == 2);
259
260 LIBCPP_ASSERT(c2.bucket_count() == 0);
261 assert(c2.size() == 0);
262 assert(c2.hash_function() == Hash(1));
263 assert(c2.key_eq() == Compare(1));
264 assert(c2.get_allocator() == Alloc(1));
265 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
266 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
267 assert(c2.max_load_factor() == 1);
268 }
269 {
270 typedef test_hash<int> Hash;
271 typedef test_equal_to<int> Compare;
272 typedef other_allocator<std::pair<const int, std::string> > Alloc;
273 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
274 typedef std::pair<int, std::string> P;
275 P a2[] =
276 {
277 P(10, "ten"),
278 P(20, "twenty"),
279 P(30, "thirty"),
280 P(40, "forty"),
281 P(50, "fifty"),
282 P(60, "sixty"),
283 P(70, "seventy"),
284 P(80, "eighty"),
285 };
286 C c1(0, Hash(1), Compare(1), Alloc(1));
287 C c2(std::begin(arr&: a2), std::end(arr&: a2), 0, Hash(2), Compare(2), Alloc(2));
288 c2.max_load_factor(z: 2);
289 c1.swap(x&: c2);
290
291 assert(c1.bucket_count() >= 8);
292 assert(c1.size() == 8);
293 assert(c1.find(10)->second == "ten");
294 assert(c1.find(20)->second == "twenty");
295 assert(c1.find(30)->second == "thirty");
296 assert(c1.find(40)->second == "forty");
297 assert(c1.find(50)->second == "fifty");
298 assert(c1.find(60)->second == "sixty");
299 assert(c1.find(70)->second == "seventy");
300 assert(c1.find(80)->second == "eighty");
301 assert(c1.hash_function() == Hash(2));
302 assert(c1.key_eq() == Compare(2));
303 assert(c1.get_allocator() == Alloc(2));
304 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
305 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
306 assert(c1.max_load_factor() == 2);
307
308 LIBCPP_ASSERT(c2.bucket_count() == 0);
309 assert(c2.size() == 0);
310 assert(c2.hash_function() == Hash(1));
311 assert(c2.key_eq() == Compare(1));
312 assert(c2.get_allocator() == Alloc(1));
313 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
314 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
315 assert(c2.max_load_factor() == 1);
316 }
317 {
318 typedef test_hash<int> Hash;
319 typedef test_equal_to<int> Compare;
320 typedef other_allocator<std::pair<const int, std::string> > Alloc;
321 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
322 typedef std::pair<int, std::string> P;
323 P a1[] =
324 {
325 P(1, "one"),
326 P(2, "two"),
327 P(3, "three"),
328 P(4, "four"),
329 P(1, "four"),
330 P(2, "four"),
331 };
332 C c1(std::begin(arr&: a1), std::end(arr&: a1), 0, Hash(1), Compare(1), Alloc(1));
333 C c2(0, Hash(2), Compare(2), Alloc(2));
334 c2.max_load_factor(z: 2);
335 c1.swap(x&: c2);
336
337 LIBCPP_ASSERT(c1.bucket_count() == 0);
338 assert(c1.size() == 0);
339 assert(c1.hash_function() == Hash(2));
340 assert(c1.key_eq() == Compare(2));
341 assert(c1.get_allocator() == Alloc(2));
342 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
343 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
344 assert(c1.max_load_factor() == 2);
345
346 assert(c2.bucket_count() >= 6);
347 assert(c2.size() == 6);
348 {
349 std::set<std::string> s;
350 s.insert(x: "one");
351 s.insert(x: "four");
352 assert(s.find(c2.find(1)->second) != s.end());
353 s.erase(position: s.find(x: c2.find(x: 1)->second));
354 assert(s.find(std::next(c2.find(1))->second) != s.end());
355 }
356 {
357 std::set<std::string> s;
358 s.insert(x: "two");
359 s.insert(x: "four");
360 assert(s.find(c2.find(2)->second) != s.end());
361 s.erase(position: s.find(x: c2.find(x: 2)->second));
362 assert(s.find(std::next(c2.find(2))->second) != s.end());
363 }
364 assert(c2.find(3)->second == "three");
365 assert(c2.find(4)->second == "four");
366 assert(c2.hash_function() == Hash(1));
367 assert(c2.key_eq() == Compare(1));
368 assert(c2.get_allocator() == Alloc(1));
369 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
370 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
371 assert(c2.max_load_factor() == 1);
372 }
373 {
374 typedef test_hash<int> Hash;
375 typedef test_equal_to<int> Compare;
376 typedef other_allocator<std::pair<const int, std::string> > Alloc;
377 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
378 typedef std::pair<int, std::string> P;
379 P a1[] =
380 {
381 P(1, "one"),
382 P(2, "two"),
383 P(3, "three"),
384 P(4, "four"),
385 P(1, "four"),
386 P(2, "four"),
387 };
388 P a2[] =
389 {
390 P(10, "ten"),
391 P(20, "twenty"),
392 P(30, "thirty"),
393 P(40, "forty"),
394 P(50, "fifty"),
395 P(60, "sixty"),
396 P(70, "seventy"),
397 P(80, "eighty"),
398 };
399 C c1(std::begin(arr&: a1), std::end(arr&: a1), 0, Hash(1), Compare(1), Alloc(1));
400 C c2(std::begin(arr&: a2), std::end(arr&: a2), 0, Hash(2), Compare(2), Alloc(2));
401 c2.max_load_factor(z: 2);
402 c1.swap(x&: c2);
403
404 assert(c1.bucket_count() >= 8);
405 assert(c1.size() == 8);
406 assert(c1.find(10)->second == "ten");
407 assert(c1.find(20)->second == "twenty");
408 assert(c1.find(30)->second == "thirty");
409 assert(c1.find(40)->second == "forty");
410 assert(c1.find(50)->second == "fifty");
411 assert(c1.find(60)->second == "sixty");
412 assert(c1.find(70)->second == "seventy");
413 assert(c1.find(80)->second == "eighty");
414 assert(c1.hash_function() == Hash(2));
415 assert(c1.key_eq() == Compare(2));
416 assert(c1.get_allocator() == Alloc(2));
417 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
418 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
419 assert(c1.max_load_factor() == 2);
420
421 assert(c2.bucket_count() >= 6);
422 assert(c2.size() == 6);
423 {
424 std::set<std::string> s;
425 s.insert(x: "one");
426 s.insert(x: "four");
427 assert(s.find(c2.find(1)->second) != s.end());
428 s.erase(position: s.find(x: c2.find(x: 1)->second));
429 assert(s.find(std::next(c2.find(1))->second) != s.end());
430 }
431 {
432 std::set<std::string> s;
433 s.insert(x: "two");
434 s.insert(x: "four");
435 assert(s.find(c2.find(2)->second) != s.end());
436 s.erase(position: s.find(x: c2.find(x: 2)->second));
437 assert(s.find(std::next(c2.find(2))->second) != s.end());
438 }
439 assert(c2.find(3)->second == "three");
440 assert(c2.find(4)->second == "four");
441 assert(c2.hash_function() == Hash(1));
442 assert(c2.key_eq() == Compare(1));
443 assert(c2.get_allocator() == Alloc(1));
444 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
445 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
446 assert(c2.max_load_factor() == 1);
447 }
448#if TEST_STD_VER >= 11
449 {
450 typedef test_hash<int> Hash;
451 typedef test_equal_to<int> Compare;
452 typedef min_allocator<std::pair<const int, std::string> > Alloc;
453 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
454 C c1(0, Hash(1), Compare(1), Alloc());
455 C c2(0, Hash(2), Compare(2), Alloc());
456 c2.max_load_factor(2);
457 c1.swap(c2);
458
459 LIBCPP_ASSERT(c1.bucket_count() == 0);
460 assert(c1.size() == 0);
461 assert(c1.hash_function() == Hash(2));
462 assert(c1.key_eq() == Compare(2));
463 assert(c1.get_allocator() == Alloc());
464 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
465 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
466 assert(c1.max_load_factor() == 2);
467
468 LIBCPP_ASSERT(c2.bucket_count() == 0);
469 assert(c2.size() == 0);
470 assert(c2.hash_function() == Hash(1));
471 assert(c2.key_eq() == Compare(1));
472 assert(c2.get_allocator() == Alloc());
473 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
474 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
475 assert(c2.max_load_factor() == 1);
476 }
477 {
478 typedef test_hash<int> Hash;
479 typedef test_equal_to<int> Compare;
480 typedef min_allocator<std::pair<const int, std::string> > Alloc;
481 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
482 typedef std::pair<int, std::string> P;
483 P a2[] =
484 {
485 P(10, "ten"),
486 P(20, "twenty"),
487 P(30, "thirty"),
488 P(40, "forty"),
489 P(50, "fifty"),
490 P(60, "sixty"),
491 P(70, "seventy"),
492 P(80, "eighty"),
493 };
494 C c1(0, Hash(1), Compare(1), Alloc());
495 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
496 c2.max_load_factor(2);
497 c1.swap(c2);
498
499 assert(c1.bucket_count() >= 8);
500 assert(c1.size() == 8);
501 assert(c1.find(10)->second == "ten");
502 assert(c1.find(20)->second == "twenty");
503 assert(c1.find(30)->second == "thirty");
504 assert(c1.find(40)->second == "forty");
505 assert(c1.find(50)->second == "fifty");
506 assert(c1.find(60)->second == "sixty");
507 assert(c1.find(70)->second == "seventy");
508 assert(c1.find(80)->second == "eighty");
509 assert(c1.hash_function() == Hash(2));
510 assert(c1.key_eq() == Compare(2));
511 assert(c1.get_allocator() == Alloc());
512 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
513 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
514 assert(c1.max_load_factor() == 2);
515
516 LIBCPP_ASSERT(c2.bucket_count() == 0);
517 assert(c2.size() == 0);
518 assert(c2.hash_function() == Hash(1));
519 assert(c2.key_eq() == Compare(1));
520 assert(c2.get_allocator() == Alloc());
521 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
522 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
523 assert(c2.max_load_factor() == 1);
524 }
525 {
526 typedef test_hash<int> Hash;
527 typedef test_equal_to<int> Compare;
528 typedef min_allocator<std::pair<const int, std::string> > Alloc;
529 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
530 typedef std::pair<int, std::string> P;
531 P a1[] =
532 {
533 P(1, "one"),
534 P(2, "two"),
535 P(3, "three"),
536 P(4, "four"),
537 P(1, "four"),
538 P(2, "four"),
539 };
540 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
541 C c2(0, Hash(2), Compare(2), Alloc());
542 c2.max_load_factor(2);
543 c1.swap(c2);
544
545 LIBCPP_ASSERT(c1.bucket_count() == 0);
546 assert(c1.size() == 0);
547 assert(c1.hash_function() == Hash(2));
548 assert(c1.key_eq() == Compare(2));
549 assert(c1.get_allocator() == Alloc());
550 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
551 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
552 assert(c1.max_load_factor() == 2);
553
554 assert(c2.bucket_count() >= 6);
555 assert(c2.size() == 6);
556 {
557 std::set<std::string> s;
558 s.insert("one");
559 s.insert("four");
560 assert(s.find(c2.find(1)->second) != s.end());
561 s.erase(s.find(c2.find(1)->second));
562 assert(s.find(std::next(c2.find(1))->second) != s.end());
563 }
564 {
565 std::set<std::string> s;
566 s.insert("two");
567 s.insert("four");
568 assert(s.find(c2.find(2)->second) != s.end());
569 s.erase(s.find(c2.find(2)->second));
570 assert(s.find(std::next(c2.find(2))->second) != s.end());
571 }
572 assert(c2.find(3)->second == "three");
573 assert(c2.find(4)->second == "four");
574 assert(c2.hash_function() == Hash(1));
575 assert(c2.key_eq() == Compare(1));
576 assert(c2.get_allocator() == Alloc());
577 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
578 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
579 assert(c2.max_load_factor() == 1);
580 }
581 {
582 typedef test_hash<int> Hash;
583 typedef test_equal_to<int> Compare;
584 typedef min_allocator<std::pair<const int, std::string> > Alloc;
585 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
586 typedef std::pair<int, std::string> P;
587 P a1[] =
588 {
589 P(1, "one"),
590 P(2, "two"),
591 P(3, "three"),
592 P(4, "four"),
593 P(1, "four"),
594 P(2, "four"),
595 };
596 P a2[] =
597 {
598 P(10, "ten"),
599 P(20, "twenty"),
600 P(30, "thirty"),
601 P(40, "forty"),
602 P(50, "fifty"),
603 P(60, "sixty"),
604 P(70, "seventy"),
605 P(80, "eighty"),
606 };
607 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
608 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
609 c2.max_load_factor(2);
610 c1.swap(c2);
611
612 assert(c1.bucket_count() >= 8);
613 assert(c1.size() == 8);
614 assert(c1.find(10)->second == "ten");
615 assert(c1.find(20)->second == "twenty");
616 assert(c1.find(30)->second == "thirty");
617 assert(c1.find(40)->second == "forty");
618 assert(c1.find(50)->second == "fifty");
619 assert(c1.find(60)->second == "sixty");
620 assert(c1.find(70)->second == "seventy");
621 assert(c1.find(80)->second == "eighty");
622 assert(c1.hash_function() == Hash(2));
623 assert(c1.key_eq() == Compare(2));
624 assert(c1.get_allocator() == Alloc());
625 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
626 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
627 assert(c1.max_load_factor() == 2);
628
629 assert(c2.bucket_count() >= 6);
630 assert(c2.size() == 6);
631 {
632 std::set<std::string> s;
633 s.insert("one");
634 s.insert("four");
635 assert(s.find(c2.find(1)->second) != s.end());
636 s.erase(s.find(c2.find(1)->second));
637 assert(s.find(std::next(c2.find(1))->second) != s.end());
638 }
639 {
640 std::set<std::string> s;
641 s.insert("two");
642 s.insert("four");
643 assert(s.find(c2.find(2)->second) != s.end());
644 s.erase(s.find(c2.find(2)->second));
645 assert(s.find(std::next(c2.find(2))->second) != s.end());
646 }
647 assert(c2.find(3)->second == "three");
648 assert(c2.find(4)->second == "four");
649 assert(c2.hash_function() == Hash(1));
650 assert(c2.key_eq() == Compare(1));
651 assert(c2.get_allocator() == Alloc());
652 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
653 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
654 assert(c2.max_load_factor() == 1);
655 }
656#endif
657
658 return 0;
659}
660

source code of libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp