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