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