Home | History | Annotate | Download | only in unord.multimap
      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 }
    586