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> 2098605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej#include <cstddef> 21bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 220809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier#include "test_macros.h" 23bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "../../test_compare.h" 24bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "../../test_hash.h" 251b92188a82b01e76ac6e8ad5f997293c2a078adcMarshall Clow#include "test_allocator.h" 26061d0cc4db18d17bf01ed14c5db0be098205bd47Marshall Clow#include "min_allocator.h" 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_hash<std::hash<int> > Hash; 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_compare<std::equal_to<int> > Compare; 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef test_allocator<int> Alloc; 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 3511f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c1(0, Hash(1), Compare(1), Alloc(1, 1)); 3611f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c2(0, Hash(2), Compare(2), Alloc(1, 2)); 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 400809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 4411f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c1.get_allocator().get_id() == 1); 4598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 4698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 490809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 5311f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c2.get_allocator().get_id() == 2); 5498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 5598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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<int> Alloc; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 7511f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c1(0, Hash(1), Compare(1), Alloc(1, 1)); 7611f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 800b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 85bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 9211f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c1.get_allocator().get_id() == 1); 9398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 9498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 970809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 10111f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c2.get_allocator().get_id() == 2); 10298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 10398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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<int> Alloc; 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 12111f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); 12211f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c2(0, Hash(2), Compare(2), Alloc(1, 2)); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 1260809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 13011f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c1.get_allocator().get_id() == 1); 13198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 13298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 1350b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 14311f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c2.get_allocator().get_id() == 2); 14498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 14598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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<int> Alloc; 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef int P; 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a1[] = 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2), 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3), 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4), 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1), 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2) 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a2[] = 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(10), 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(20), 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(30), 168bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(40), 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(50), 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(60), 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(70), 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(80) 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 17411f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); 17511f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c2.max_load_factor(2); 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant c1.swap(c2); 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 1790b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.size() == 8); 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(10) == 10); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(20) == 20); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(30) == 30); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(40) == 40); 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(50) == 50); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(60) == 60); 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(70) == 70); 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*c1.find(80) == 80); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.hash_function() == Hash(2)); 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.key_eq() == Compare(2)); 19111f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c1.get_allocator().get_id() == 1); 19298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 19398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 1960b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.size() == 6); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(1) == 2); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(2) == 2); 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(3) == 1); 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.count(4) == 1); 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.hash_function() == Hash(1)); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.key_eq() == Compare(1)); 20411f64dcc5864f3d237dd4fd35f56793022567257Eric Fiselier assert(c2.get_allocator().get_id() == 2); 20598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 20698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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<int> Alloc; 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 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 2200809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 22598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 22698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 2290809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 23498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 23598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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 2600b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 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)); 27398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 27498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 2770809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 28298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 28398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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 3060809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_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)); 31198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 31298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 3150b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 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)); 32498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 32598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(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 3590b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 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)); 37298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 37398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c1.max_load_factor() == 2); 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 3760b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 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)); 38598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 38698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c2.max_load_factor() == 1); 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 389d24c465beaec2fe9a0e365e6379cd5d3acaeb2caEric Fiselier#if TEST_STD_VER >= 11 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 C c1(0, Hash(1), Compare(1), Alloc()); 3967a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(0, Hash(2), Compare(2), Alloc()); 3977a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 3987a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 3997a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4000809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_ASSERT(c1.bucket_count() == 0); 4017a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 0); 4027a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4037a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4047a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 40598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 40698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 4077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4090809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_ASSERT(c2.bucket_count() == 0); 4107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 0); 4117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 4127a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 4137a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 41498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 41598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 4167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 4177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 4187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 4207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 4217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<int> Alloc; 4227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 4237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef int P; 4247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a2[] = 4257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(10), 4277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(20), 4287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(30), 4297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(40), 4307a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(50), 4317a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(60), 4327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(70), 4337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(80) 4347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 4357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(0, Hash(1), Compare(1), Alloc()); 4367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 4377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 4387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 4397a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4400b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 4417a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 8); 4427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(10) == 10); 4437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(20) == 20); 4447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(30) == 30); 4457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(40) == 40); 4467a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(50) == 50); 4477a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(60) == 60); 4487a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(70) == 70); 4497a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(80) == 80); 4507a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4517a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4527a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 45398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 45498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 4557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4567a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4570809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_ASSERT(c2.bucket_count() == 0); 4587a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 0); 4597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 4607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 4617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 46298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 46398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 4647a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 4657a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 4667a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4677a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 4687a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 4697a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<int> Alloc; 4707a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 4717a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef int P; 4727a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a1[] = 4737a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 4747a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1), 4757a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2), 4767a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(3), 4777a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(4), 4787a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1), 4797a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2) 4807a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 4817a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 4827a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(0, Hash(2), Compare(2), Alloc()); 4837a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 4847a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 4857a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4860809a7f62b7e43e2e5f3a31f66dd8cf097cfeb71Eric Fiselier LIBCPP_ASSERT(c1.bucket_count() == 0); 4877a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 0); 4887a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 4897a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 4907a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 49198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 49298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 4937a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 4947a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 4950b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 4967a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 6); 4977a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(1) == 2); 4987a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(2) == 2); 4997a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(3) == 1); 5007a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(4) == 1); 5017a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 5027a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 5037a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 50498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 50598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 5067a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 5077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 5087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5097a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_hash<std::hash<int> > Hash; 5107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef test_compare<std::equal_to<int> > Compare; 5117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef min_allocator<int> Alloc; 5127a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; 5137a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef int P; 5147a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a1[] = 5157a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1), 5177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2), 5187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(3), 5197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(4), 5207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1), 5217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2) 5227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 5237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a2[] = 5247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 5257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(10), 5267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(20), 5277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(30), 5287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(40), 5297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(50), 5307a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(60), 5317a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(70), 5327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(80) 5337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 5347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 5357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 5367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c2.max_load_factor(2); 5377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant c1.swap(c2); 5387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 5390b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c1.bucket_count() >= 8); 5407a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.size() == 8); 5417a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(10) == 10); 5427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(20) == 20); 5437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(30) == 30); 5447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(40) == 40); 5457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(50) == 50); 5467a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(60) == 60); 5477a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(70) == 70); 5487a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(*c1.find(80) == 80); 5497a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.hash_function() == Hash(2)); 5507a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.key_eq() == Compare(2)); 5517a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.get_allocator() == Alloc()); 55298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 55398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 5547a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c1.max_load_factor() == 2); 5557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 5560b2e1c23fbafa17927e2ca48ef4a9d8c2144ed2bStephan T. Lavavej assert(c2.bucket_count() >= 6); 5577a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.size() == 6); 5587a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(1) == 2); 5597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(2) == 2); 5607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(3) == 1); 5617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.count(4) == 1); 5627a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.hash_function() == Hash(1)); 5637a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.key_eq() == Compare(1)); 5647a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.get_allocator() == Alloc()); 56598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 56698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 5677a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c2.max_load_factor() == 1); 5687a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 5697a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant#endif 570bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 571