test/std/containers/unord/unord.multimap/swap_member.pass.cpp

   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 // <unordered_map>
  11
  12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
  13 //           class Alloc = allocator<pair<const Key, T>>>
  14 // class unordered_multimap
  15
  16 // void swap(unordered_multimap& __u);
  17
  18 #include <unordered_map>
  19 #include <string>
  20 #include <cassert>
  21 #include <cstddef>
  22
  23 #include "test_macros.h"
  24 #include "../../test_compare.h"
  25 #include "../../test_hash.h"
  26 #include "test_allocator.h"
  27
  28 #include "min_allocator.h"
  29
  30 int main()
  31 {
  32     {
  33         typedef test_hash<std::hash<int> > Hash;
  34         typedef test_compare<std::equal_to<int> > Compare;
  35         typedef test_allocator<std::pair<const int, std::string> > Alloc;
  36         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
  37         typedef std::pair<int, std::string> P;
  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(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<std::hash<int> > Hash;
  63         typedef test_compare<std::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(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
  80         c2.max_load_factor(2);
  81         c1.swap(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<std::hash<int> > Hash;
 111         typedef test_compare<std::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(a1), std::end(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(2);
 127         c1.swap(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         assert(c2.find(1)->second == "one");
 141         assert(next(c2.find(1))->second == "four");
 142         assert(c2.find(2)->second == "two");
 143         assert(next(c2.find(2))->second == "four");
 144         assert(c2.find(3)->second == "three");
 145         assert(c2.find(4)->second == "four");
 146         assert(c2.hash_function() == Hash(1));
 147         assert(c2.key_eq() == Compare(1));
 148         assert(c2.get_allocator().get_id() == 2);
 149         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 150         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 151         assert(c2.max_load_factor() == 1);
 152     }
 153     {
 154         typedef test_hash<std::hash<int> > Hash;
 155         typedef test_compare<std::equal_to<int> > Compare;
 156         typedef test_allocator<std::pair<const int, std::string> > Alloc;
 157         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 158         typedef std::pair<int, std::string> P;
 159         P a1[] =
 160         {
 161             P(1, "one"),
 162             P(2, "two"),
 163             P(3, "three"),
 164             P(4, "four"),
 165             P(1, "four"),
 166             P(2, "four"),
 167         };
 168         P a2[] =
 169         {
 170             P(10, "ten"),
 171             P(20, "twenty"),
 172             P(30, "thirty"),
 173             P(40, "forty"),
 174             P(50, "fifty"),
 175             P(60, "sixty"),
 176             P(70, "seventy"),
 177             P(80, "eighty"),
 178         };
 179         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
 180         C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
 181         c2.max_load_factor(2);
 182         c1.swap(c2);
 183
 184         assert(c1.bucket_count() >= 8);
 185         assert(c1.size() == 8);
 186         assert(c1.find(10)->second == "ten");
 187         assert(c1.find(20)->second == "twenty");
 188         assert(c1.find(30)->second == "thirty");
 189         assert(c1.find(40)->second == "forty");
 190         assert(c1.find(50)->second == "fifty");
 191         assert(c1.find(60)->second == "sixty");
 192         assert(c1.find(70)->second == "seventy");
 193         assert(c1.find(80)->second == "eighty");
 194         assert(c1.hash_function() == Hash(2));
 195         assert(c1.key_eq() == Compare(2));
 196         assert(c1.get_allocator().get_id() == 1);
 197         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 198         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 199         assert(c1.max_load_factor() == 2);
 200
 201         assert(c2.bucket_count() >= 6);
 202         assert(c2.size() == 6);
 203         assert(c2.find(1)->second == "one");
 204         assert(next(c2.find(1))->second == "four");
 205         assert(c2.find(2)->second == "two");
 206         assert(next(c2.find(2))->second == "four");
 207         assert(c2.find(3)->second == "three");
 208         assert(c2.find(4)->second == "four");
 209         assert(c2.hash_function() == Hash(1));
 210         assert(c2.key_eq() == Compare(1));
 211         assert(c2.get_allocator().get_id() == 2);
 212         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 213         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 214         assert(c2.max_load_factor() == 1);
 215     }
 216
 217     {
 218         typedef test_hash<std::hash<int> > Hash;
 219         typedef test_compare<std::equal_to<int> > Compare;
 220         typedef other_allocator<std::pair<const int, std::string> > Alloc;
 221         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 222         typedef std::pair<int, std::string> P;
 223         C c1(0, Hash(1), Compare(1), Alloc(1));
 224         C c2(0, Hash(2), Compare(2), Alloc(2));
 225         c2.max_load_factor(2);
 226         c1.swap(c2);
 227
 228         LIBCPP_ASSERT(c1.bucket_count() == 0);
 229         assert(c1.size() == 0);
 230         assert(c1.hash_function() == Hash(2));
 231         assert(c1.key_eq() == Compare(2));
 232         assert(c1.get_allocator() == Alloc(2));
 233         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 234         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 235         assert(c1.max_load_factor() == 2);
 236
 237         LIBCPP_ASSERT(c2.bucket_count() == 0);
 238         assert(c2.size() == 0);
 239         assert(c2.hash_function() == Hash(1));
 240         assert(c2.key_eq() == Compare(1));
 241         assert(c2.get_allocator() == Alloc(1));
 242         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 243         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 244         assert(c2.max_load_factor() == 1);
 245     }
 246     {
 247         typedef test_hash<std::hash<int> > Hash;
 248         typedef test_compare<std::equal_to<int> > Compare;
 249         typedef other_allocator<std::pair<const int, std::string> > Alloc;
 250         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 251         typedef std::pair<int, std::string> P;
 252         P a2[] =
 253         {
 254             P(10, "ten"),
 255             P(20, "twenty"),
 256             P(30, "thirty"),
 257             P(40, "forty"),
 258             P(50, "fifty"),
 259             P(60, "sixty"),
 260             P(70, "seventy"),
 261             P(80, "eighty"),
 262         };
 263         C c1(0, Hash(1), Compare(1), Alloc(1));
 264         C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
 265         c2.max_load_factor(2);
 266         c1.swap(c2);
 267
 268         assert(c1.bucket_count() >= 8);
 269         assert(c1.size() == 8);
 270         assert(c1.find(10)->second == "ten");
 271         assert(c1.find(20)->second == "twenty");
 272         assert(c1.find(30)->second == "thirty");
 273         assert(c1.find(40)->second == "forty");
 274         assert(c1.find(50)->second == "fifty");
 275         assert(c1.find(60)->second == "sixty");
 276         assert(c1.find(70)->second == "seventy");
 277         assert(c1.find(80)->second == "eighty");
 278         assert(c1.hash_function() == Hash(2));
 279         assert(c1.key_eq() == Compare(2));
 280         assert(c1.get_allocator() == Alloc(2));
 281         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 282         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 283         assert(c1.max_load_factor() == 2);
 284
 285         LIBCPP_ASSERT(c2.bucket_count() == 0);
 286         assert(c2.size() == 0);
 287         assert(c2.hash_function() == Hash(1));
 288         assert(c2.key_eq() == Compare(1));
 289         assert(c2.get_allocator() == Alloc(1));
 290         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 291         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 292         assert(c2.max_load_factor() == 1);
 293     }
 294     {
 295         typedef test_hash<std::hash<int> > Hash;
 296         typedef test_compare<std::equal_to<int> > Compare;
 297         typedef other_allocator<std::pair<const int, std::string> > Alloc;
 298         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 299         typedef std::pair<int, std::string> P;
 300         P a1[] =
 301         {
 302             P(1, "one"),
 303             P(2, "two"),
 304             P(3, "three"),
 305             P(4, "four"),
 306             P(1, "four"),
 307             P(2, "four"),
 308         };
 309         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
 310         C c2(0, Hash(2), Compare(2), Alloc(2));
 311         c2.max_load_factor(2);
 312         c1.swap(c2);
 313
 314         LIBCPP_ASSERT(c1.bucket_count() == 0);
 315         assert(c1.size() == 0);
 316         assert(c1.hash_function() == Hash(2));
 317         assert(c1.key_eq() == Compare(2));
 318         assert(c1.get_allocator() == Alloc(2));
 319         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 320         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 321         assert(c1.max_load_factor() == 2);
 322
 323         assert(c2.bucket_count() >= 6);
 324         assert(c2.size() == 6);
 325         assert(c2.find(1)->second == "one");
 326         assert(next(c2.find(1))->second == "four");
 327         assert(c2.find(2)->second == "two");
 328         assert(next(c2.find(2))->second == "four");
 329         assert(c2.find(3)->second == "three");
 330         assert(c2.find(4)->second == "four");
 331         assert(c2.hash_function() == Hash(1));
 332         assert(c2.key_eq() == Compare(1));
 333         assert(c2.get_allocator() == Alloc(1));
 334         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 335         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 336         assert(c2.max_load_factor() == 1);
 337     }
 338     {
 339         typedef test_hash<std::hash<int> > Hash;
 340         typedef test_compare<std::equal_to<int> > Compare;
 341         typedef other_allocator<std::pair<const int, std::string> > Alloc;
 342         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 343         typedef std::pair<int, std::string> P;
 344         P a1[] =
 345         {
 346             P(1, "one"),
 347             P(2, "two"),
 348             P(3, "three"),
 349             P(4, "four"),
 350             P(1, "four"),
 351             P(2, "four"),
 352         };
 353         P a2[] =
 354         {
 355             P(10, "ten"),
 356             P(20, "twenty"),
 357             P(30, "thirty"),
 358             P(40, "forty"),
 359             P(50, "fifty"),
 360             P(60, "sixty"),
 361             P(70, "seventy"),
 362             P(80, "eighty"),
 363         };
 364         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
 365         C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
 366         c2.max_load_factor(2);
 367         c1.swap(c2);
 368
 369         assert(c1.bucket_count() >= 8);
 370         assert(c1.size() == 8);
 371         assert(c1.find(10)->second == "ten");
 372         assert(c1.find(20)->second == "twenty");
 373         assert(c1.find(30)->second == "thirty");
 374         assert(c1.find(40)->second == "forty");
 375         assert(c1.find(50)->second == "fifty");
 376         assert(c1.find(60)->second == "sixty");
 377         assert(c1.find(70)->second == "seventy");
 378         assert(c1.find(80)->second == "eighty");
 379         assert(c1.hash_function() == Hash(2));
 380         assert(c1.key_eq() == Compare(2));
 381         assert(c1.get_allocator() == Alloc(2));
 382         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 383         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 384         assert(c1.max_load_factor() == 2);
 385
 386         assert(c2.bucket_count() >= 6);
 387         assert(c2.size() == 6);
 388         assert(c2.find(1)->second == "one");
 389         assert(next(c2.find(1))->second == "four");
 390         assert(c2.find(2)->second == "two");
 391         assert(next(c2.find(2))->second == "four");
 392         assert(c2.find(3)->second == "three");
 393         assert(c2.find(4)->second == "four");
 394         assert(c2.hash_function() == Hash(1));
 395         assert(c2.key_eq() == Compare(1));
 396         assert(c2.get_allocator() == Alloc(1));
 397         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 398         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 399         assert(c2.max_load_factor() == 1);
 400     }
 401 #if TEST_STD_VER >= 11
 402     {
 403         typedef test_hash<std::hash<int> > Hash;
 404         typedef test_compare<std::equal_to<int> > Compare;
 405         typedef min_allocator<std::pair<const int, std::string> > Alloc;
 406         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 407         typedef std::pair<int, std::string> P;
 408         C c1(0, Hash(1), Compare(1), Alloc());
 409         C c2(0, Hash(2), Compare(2), Alloc());
 410         c2.max_load_factor(2);
 411         c1.swap(c2);
 412
 413         LIBCPP_ASSERT(c1.bucket_count() == 0);
 414         assert(c1.size() == 0);
 415         assert(c1.hash_function() == Hash(2));
 416         assert(c1.key_eq() == Compare(2));
 417         assert(c1.get_allocator() == Alloc());
 418         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 419         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 420         assert(c1.max_load_factor() == 2);
 421
 422         LIBCPP_ASSERT(c2.bucket_count() == 0);
 423         assert(c2.size() == 0);
 424         assert(c2.hash_function() == Hash(1));
 425         assert(c2.key_eq() == Compare(1));
 426         assert(c2.get_allocator() == Alloc());
 427         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 428         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 429         assert(c2.max_load_factor() == 1);
 430     }
 431     {
 432         typedef test_hash<std::hash<int> > Hash;
 433         typedef test_compare<std::equal_to<int> > Compare;
 434         typedef min_allocator<std::pair<const int, std::string> > Alloc;
 435         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 436         typedef std::pair<int, std::string> P;
 437         P a2[] =
 438         {
 439             P(10, "ten"),
 440             P(20, "twenty"),
 441             P(30, "thirty"),
 442             P(40, "forty"),
 443             P(50, "fifty"),
 444             P(60, "sixty"),
 445             P(70, "seventy"),
 446             P(80, "eighty"),
 447         };
 448         C c1(0, Hash(1), Compare(1), Alloc());
 449         C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
 450         c2.max_load_factor(2);
 451         c1.swap(c2);
 452
 453         assert(c1.bucket_count() >= 8);
 454         assert(c1.size() == 8);
 455         assert(c1.find(10)->second == "ten");
 456         assert(c1.find(20)->second == "twenty");
 457         assert(c1.find(30)->second == "thirty");
 458         assert(c1.find(40)->second == "forty");
 459         assert(c1.find(50)->second == "fifty");
 460         assert(c1.find(60)->second == "sixty");
 461         assert(c1.find(70)->second == "seventy");
 462         assert(c1.find(80)->second == "eighty");
 463         assert(c1.hash_function() == Hash(2));
 464         assert(c1.key_eq() == Compare(2));
 465         assert(c1.get_allocator() == Alloc());
 466         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 467         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 468         assert(c1.max_load_factor() == 2);
 469
 470         LIBCPP_ASSERT(c2.bucket_count() == 0);
 471         assert(c2.size() == 0);
 472         assert(c2.hash_function() == Hash(1));
 473         assert(c2.key_eq() == Compare(1));
 474         assert(c2.get_allocator() == Alloc());
 475         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 476         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 477         assert(c2.max_load_factor() == 1);
 478     }
 479     {
 480         typedef test_hash<std::hash<int> > Hash;
 481         typedef test_compare<std::equal_to<int> > Compare;
 482         typedef min_allocator<std::pair<const int, std::string> > Alloc;
 483         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 484         typedef std::pair<int, std::string> P;
 485         P a1[] =
 486         {
 487             P(1, "one"),
 488             P(2, "two"),
 489             P(3, "three"),
 490             P(4, "four"),
 491             P(1, "four"),
 492             P(2, "four"),
 493         };
 494         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
 495         C c2(0, Hash(2), Compare(2), Alloc());
 496         c2.max_load_factor(2);
 497         c1.swap(c2);
 498
 499         LIBCPP_ASSERT(c1.bucket_count() == 0);
 500         assert(c1.size() == 0);
 501         assert(c1.hash_function() == Hash(2));
 502         assert(c1.key_eq() == Compare(2));
 503         assert(c1.get_allocator() == Alloc());
 504         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 505         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 506         assert(c1.max_load_factor() == 2);
 507
 508         assert(c2.bucket_count() >= 6);
 509         assert(c2.size() == 6);
 510         assert(c2.find(1)->second == "one");
 511         assert(next(c2.find(1))->second == "four");
 512         assert(c2.find(2)->second == "two");
 513         assert(next(c2.find(2))->second == "four");
 514         assert(c2.find(3)->second == "three");
 515         assert(c2.find(4)->second == "four");
 516         assert(c2.hash_function() == Hash(1));
 517         assert(c2.key_eq() == Compare(1));
 518         assert(c2.get_allocator() == Alloc());
 519         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 520         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 521         assert(c2.max_load_factor() == 1);
 522     }
 523     {
 524         typedef test_hash<std::hash<int> > Hash;
 525         typedef test_compare<std::equal_to<int> > Compare;
 526         typedef min_allocator<std::pair<const int, std::string> > Alloc;
 527         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
 528         typedef std::pair<int, std::string> P;
 529         P a1[] =
 530         {
 531             P(1, "one"),
 532             P(2, "two"),
 533             P(3, "three"),
 534             P(4, "four"),
 535             P(1, "four"),
 536             P(2, "four"),
 537         };
 538         P a2[] =
 539         {
 540             P(10, "ten"),
 541             P(20, "twenty"),
 542             P(30, "thirty"),
 543             P(40, "forty"),
 544             P(50, "fifty"),
 545             P(60, "sixty"),
 546             P(70, "seventy"),
 547             P(80, "eighty"),
 548         };
 549         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
 550         C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
 551         c2.max_load_factor(2);
 552         c1.swap(c2);
 553
 554         assert(c1.bucket_count() >= 8);
 555         assert(c1.size() == 8);
 556         assert(c1.find(10)->second == "ten");
 557         assert(c1.find(20)->second == "twenty");
 558         assert(c1.find(30)->second == "thirty");
 559         assert(c1.find(40)->second == "forty");
 560         assert(c1.find(50)->second == "fifty");
 561         assert(c1.find(60)->second == "sixty");
 562         assert(c1.find(70)->second == "seventy");
 563         assert(c1.find(80)->second == "eighty");
 564         assert(c1.hash_function() == Hash(2));
 565         assert(c1.key_eq() == Compare(2));
 566         assert(c1.get_allocator() == Alloc());
 567         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
 568         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
 569         assert(c1.max_load_factor() == 2);
 570
 571         assert(c2.bucket_count() >= 6);
 572         assert(c2.size() == 6);
 573         assert(c2.find(1)->second == "one");
 574         assert(next(c2.find(1))->second == "four");
 575         assert(c2.find(2)->second == "two");
 576         assert(next(c2.find(2))->second == "four");
 577         assert(c2.find(3)->second == "three");
 578         assert(c2.find(4)->second == "four");
 579         assert(c2.hash_function() == Hash(1));
 580         assert(c2.key_eq() == Compare(1));
 581         assert(c2.get_allocator() == Alloc());
 582         assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
 583         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
 584         assert(c2.max_load_factor() == 1);
 585     }
 586 #endif
 587 }