swap_member.pass.cpp revision 08f8ac6951f1d7c13e4fd342c4e01c270aff11dc
1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// This file is dual licensed under the MIT and the University of Illinois Open 6b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// Source Licenses. See LICENSE.TXT for details. 7bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 8bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 9bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 10bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// <unordered_map> 11bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 12bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// class Alloc = allocator<pair<const Key, T>>> 14bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// class unordered_map 15bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 16bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// void swap(unordered_map& __u); 17bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 18bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <unordered_map> 19bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <string> 20bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <cassert> 21bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 22bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "../../test_compare.h" 23bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "../../test_hash.h" 241b92188a82b01e76ac6e8ad5f997293c2a078adcMarshall Clow#include "test_allocator.h" 25061d0cc4db18d17bf01ed14c5db0be098205bd47Marshall Clow#include "min_allocator.h" 26bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<std::pair<const int, std::string> > Alloc; 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 35bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 36bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 40bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<std::pair<const int, std::string> > Alloc; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10, "ten"), 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20, "twenty"), 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30, "thirty"), 6908f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50, "fifty"), 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60, "sixty"), 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70, "seventy"), 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80, "eighty"), 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(10) == "ten"); 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(20) == "twenty"); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(30) == "thirty"); 8508f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(50) == "fifty"); 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(60) == "sixty"); 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(70) == "seventy"); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(80) == "eighty"); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 108bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 109bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<std::pair<const int, std::string> > Alloc; 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "one"), 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "two"), 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3, "three"), 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4, "four"), 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "four"), 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "four"), 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 131bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 132bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 5); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 4); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(1) == "one"); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(2) == "two"); 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(3) == "three"); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(4) == "four"); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 149bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 150bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<std::pair<const int, std::string> > Alloc; 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "one"), 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "two"), 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3, "three"), 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4, "four"), 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "four"), 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "four"), 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10, "ten"), 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20, "twenty"), 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30, "thirty"), 16808f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50, "fifty"), 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60, "sixty"), 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70, "seventy"), 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80, "eighty"), 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(10) == "ten"); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(20) == "twenty"); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(30) == "thirty"); 18408f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(50) == "fifty"); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(60) == "sixty"); 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(70) == "seventy"); 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(80) == "eighty"); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 5); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 4); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(1) == "one"); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(2) == "two"); 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(3) == "three"); 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(4) == "four"); 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 204bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 205bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 206bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 207bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 208bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 209bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 210bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 211bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 212bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 213bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<std::pair<const int, std::string> > Alloc; 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 215bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 216bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 217bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 218bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 219bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 220bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 221bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 222bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 223bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 224bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 225bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 226bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 229bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 230bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 231bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 232bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 233bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 234bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 235bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 236bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 237bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 238bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 239bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 240bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 241bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 242bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<std::pair<const int, std::string> > Alloc; 243bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 244bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 245bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 246bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 247bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10, "ten"), 248bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20, "twenty"), 249bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30, "thirty"), 25008f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 251bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50, "fifty"), 252bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60, "sixty"), 253bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70, "seventy"), 254bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80, "eighty"), 255bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 256bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 257bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 258bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 259bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 260bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 261bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 262bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 263bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(10) == "ten"); 264bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(20) == "twenty"); 265bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(30) == "thirty"); 26608f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 267bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(50) == "fifty"); 268bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(60) == "sixty"); 269bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(70) == "seventy"); 270bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(80) == "eighty"); 271bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 272bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 273bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 274bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 277bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 278bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 279bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 280bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 281bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 282bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 283bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 284bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 285bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 286bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 287bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 288bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 289bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 290bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<std::pair<const int, std::string> > Alloc; 291bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 292bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 293bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 294bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 295bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "one"), 296bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "two"), 297bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3, "three"), 298bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4, "four"), 299bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "four"), 300bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "four"), 301bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 302bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 303bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 304bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 305bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 306bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 307bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 308bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 309bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 310bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 311bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 312bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 315bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 316bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 5); 317bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 4); 318bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(1) == "one"); 319bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(2) == "two"); 320bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(3) == "three"); 321bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(4) == "four"); 322bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 323bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 324bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 325bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 326bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 327bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 328bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 329bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 330bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 331bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 332bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<std::pair<const int, std::string> > Alloc; 333bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 334bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 335bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 336bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 337bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "one"), 338bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "two"), 339bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3, "three"), 340bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4, "four"), 341bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "four"), 342bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "four"), 343bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 344bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 345bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 346bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10, "ten"), 347bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20, "twenty"), 348bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30, "thirty"), 34908f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 350bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50, "fifty"), 351bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60, "sixty"), 352bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70, "seventy"), 353bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80, "eighty"), 354bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 355bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 356bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 357bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 358bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 359bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 360bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 361bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 362bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(10) == "ten"); 363bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(20) == "twenty"); 364bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(30) == "thirty"); 36508f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 366bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(50) == "fifty"); 367bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(60) == "sixty"); 368bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(70) == "seventy"); 369bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.at(80) == "eighty"); 370bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 371bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 372bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 373bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 376bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 377bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 5); 378bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 4); 379bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(1) == "one"); 380bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(2) == "two"); 381bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(3) == "three"); 382bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.at(4) == "four"); 383bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 384bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 385bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 386bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 389bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 3907a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant#if __cplusplus >= 201103L 3917a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 3927a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 3937a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 3947a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<std::pair<const int, std::string> > Alloc; 3957a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 3967a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<int, std::string> P; 3977a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(0, Hash(1), Compare(1), Alloc()); 3987a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(0, Hash(2), Compare(2), Alloc()); 3997a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 4007a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 4017a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4027a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.bucket_count() == 0); 4037a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 0); 4047a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4057a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4067a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 4077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 4087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 4097a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.bucket_count() == 0); 4127a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 0); 4137a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 4147a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 4157a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 4167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 4177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 4187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 4197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 4207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 4227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 4237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<std::pair<const int, std::string> > Alloc; 4247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 4257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<int, std::string> P; 4267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a2[] = 4277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(10, "ten"), 4297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(20, "twenty"), 4307a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(30, "thirty"), 43108f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 4327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(50, "fifty"), 4337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(60, "sixty"), 4347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(70, "seventy"), 4357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(80, "eighty"), 4367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 4377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(0, Hash(1), Compare(1), Alloc()); 4387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 4397a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 4407a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 4417a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.bucket_count() >= 11); 4437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 8); 4447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(10) == "ten"); 4457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(20) == "twenty"); 4467a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(30) == "thirty"); 44708f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 4487a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(50) == "fifty"); 4497a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(60) == "sixty"); 4507a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(70) == "seventy"); 4517a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(80) == "eighty"); 4527a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4537a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4547a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 4557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 4567a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 4577a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4587a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.bucket_count() == 0); 4607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 0); 4617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 4627a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 4637a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 4647a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 4657a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 4667a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 4677a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 4687a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4697a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 4707a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 4717a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<std::pair<const int, std::string> > Alloc; 4727a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 4737a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<int, std::string> P; 4747a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a1[] = 4757a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4767a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "one"), 4777a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "two"), 4787a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(3, "three"), 4797a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(4, "four"), 4807a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "four"), 4817a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "four"), 4827a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 4837a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 4847a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(0, Hash(2), Compare(2), Alloc()); 4857a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 4867a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 4877a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4887a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.bucket_count() == 0); 4897a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 0); 4907a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4917a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4927a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 4937a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 4947a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 4957a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4967a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4977a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.bucket_count() >= 5); 4987a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 4); 4997a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(1) == "one"); 5007a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(2) == "two"); 5017a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(3) == "three"); 5027a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(4) == "four"); 5037a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 5047a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 5057a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 5067a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 5077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 5087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 5097a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 5107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 5127a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 5137a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<std::pair<const int, std::string> > Alloc; 5147a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; 5157a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<int, std::string> P; 5167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a1[] = 5177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "one"), 5197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "two"), 5207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(3, "three"), 5217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(4, "four"), 5227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "four"), 5237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "four"), 5247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 5257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a2[] = 5267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(10, "ten"), 5287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(20, "twenty"), 5297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(30, "thirty"), 53008f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker P(40, "forty"), 5317a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(50, "fifty"), 5327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(60, "sixty"), 5337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(70, "seventy"), 5347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(80, "eighty"), 5357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 5367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 5377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 5387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 5397a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 5407a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 5417a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.bucket_count() >= 11); 5427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 8); 5437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(10) == "ten"); 5447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(20) == "twenty"); 5457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(30) == "thirty"); 54608f8ac6951f1d7c13e4fd342c4e01c270aff11dcAlp Toker assert(c1.at(40) == "forty"); 5477a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(50) == "fifty"); 5487a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(60) == "sixty"); 5497a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(70) == "seventy"); 5507a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.at(80) == "eighty"); 5517a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 5527a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 5537a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 5547a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 5557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 5567a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 5577a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 5587a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.bucket_count() >= 5); 5597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 4); 5607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(1) == "one"); 5617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(2) == "two"); 5627a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(3) == "three"); 5637a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.at(4) == "four"); 5647a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 5657a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 5667a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 5677a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 5687a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 5697a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 5707a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 5717a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant#endif 572bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 573