swap_non_member.pass.cpp revision f5256e16dfc425c1d466f6308d4026d529ce9e0b
1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// This file is distributed under the University of Illinois Open Source 6bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// License. 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& x, unordered_multiset& y); 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" 23bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "../../../test_allocator.h" 24bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 25bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 26bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<int> Alloc; 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 35bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 36bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 40bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<int> Alloc; 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 85bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<int> Alloc; 108bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 109bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 131bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 132bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 7); 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 149bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<int> Alloc; 150bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 168bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(1)); 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 7); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(2)); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 204bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 205bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 206bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 207bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 208bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 209bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 210bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 211bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<int> Alloc; 212bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 213bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 215bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 216bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 217bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 218bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 219bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 220bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 221bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 222bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 223bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 224bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 225bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 226bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 229bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 230bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 231bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 232bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 233bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 234bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 235bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 236bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 237bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 238bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 239bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 240bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<int> Alloc; 241bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 242bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 243bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 244bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 245bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 246bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 247bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 248bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 249bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 250bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 251bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 252bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 253bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 254bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(0, Hash(1), Compare(1), Alloc(1)); 255bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 256bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 257bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 258bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 259bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 260bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 261bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 262bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 263bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 264bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 265bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 266bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 267bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 268bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 269bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 270bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 271bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 272bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 273bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 274bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() == 0); 277bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 0); 278bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 279bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 280bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 281bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 282bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 283bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 284bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 285bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 286bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 287bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 288bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<int> Alloc; 289bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 290bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 291bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 292bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 293bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 294bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 295bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 296bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 297bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 298bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 299bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 300bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 301bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(0, Hash(2), Compare(2), Alloc(2)); 302bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 303bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 304bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 305bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() == 0); 306bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 0); 307bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 308bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 309bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 310bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 311bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 312bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 7); 315bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 316bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 317bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 318bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 319bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 320bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 321bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 322bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 323bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 324bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 325bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 326bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 327bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 328bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 329bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 330bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef other_allocator<int> Alloc; 331bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 332bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 333bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 334bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 335bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 336bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 337bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 338bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 339bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 340bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 341bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 342bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 343bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 344bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 345bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 346bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 347bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 348bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 349bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 350bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 351bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 352bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 353bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 354bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 355bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 356bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant swap(c1, c2); 357bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 358bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.bucket_count() >= 11); 359bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 360bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 361bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 362bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 363bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 364bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 365bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 366bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 367bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 368bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 369bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 370bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.get_allocator() == Alloc(2)); 371bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.begin(), c1.end()) == c1.size()); 372bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 373bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.bucket_count() >= 7); 376bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 377bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 378bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 379bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 380bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 381bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 382bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 383bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.get_allocator() == Alloc(1)); 384bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.begin(), c2.end()) == c2.size()); 385bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 386bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 389