assign_move.pass.cpp (8859B)
1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // UNSUPPORTED: c++98, c++03 11 12 // <unordered_set> 13 14 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, 15 // class Alloc = allocator<Value>> 16 // class unordered_multiset 17 18 // unordered_multiset& operator=(unordered_multiset&& u); 19 20 #include <unordered_set> 21 #include <cassert> 22 #include <cfloat> 23 #include <cmath> 24 #include <cstddef> 25 26 #include "test_macros.h" 27 #include "../../../test_compare.h" 28 #include "../../../test_hash.h" 29 #include "test_allocator.h" 30 #include "min_allocator.h" 31 32 int main() 33 { 34 { 35 typedef test_allocator<int> A; 36 typedef std::unordered_multiset<int, 37 test_hash<std::hash<int> >, 38 test_compare<std::equal_to<int> >, 39 A 40 > C; 41 typedef int P; 42 P a[] = 43 { 44 P(1), 45 P(2), 46 P(3), 47 P(4), 48 P(1), 49 P(2) 50 }; 51 C c0(a, a + sizeof(a)/sizeof(a[0]), 52 7, 53 test_hash<std::hash<int> >(8), 54 test_compare<std::equal_to<int> >(9), 55 A(10) 56 ); 57 C c(a, a + 2, 58 7, 59 test_hash<std::hash<int> >(2), 60 test_compare<std::equal_to<int> >(3), 61 A(4) 62 ); 63 c = std::move(c0); 64 LIBCPP_ASSERT(c.bucket_count() == 7); 65 assert(c.size() == 6); 66 C::const_iterator i = c.cbegin(); 67 assert(*i == 1); 68 ++i; 69 assert(*i == 1); 70 ++i; 71 assert(*i == 2); 72 ++i; 73 assert(*i == 2); 74 ++i; 75 assert(*i == 3); 76 ++i; 77 assert(*i == 4); 78 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 79 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 80 assert(c.get_allocator() == A(4)); 81 assert(!c.empty()); 82 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 83 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 84 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 85 assert(c.max_load_factor() == 1); 86 } 87 { 88 typedef test_allocator<int> A; 89 typedef std::unordered_multiset<int, 90 test_hash<std::hash<int> >, 91 test_compare<std::equal_to<int> >, 92 A 93 > C; 94 typedef int P; 95 P a[] = 96 { 97 P(1), 98 P(2), 99 P(3), 100 P(4), 101 P(1), 102 P(2) 103 }; 104 C c0(a, a + sizeof(a)/sizeof(a[0]), 105 7, 106 test_hash<std::hash<int> >(8), 107 test_compare<std::equal_to<int> >(9), 108 A(10) 109 ); 110 C c(a, a + 2, 111 7, 112 test_hash<std::hash<int> >(2), 113 test_compare<std::equal_to<int> >(3), 114 A(10) 115 ); 116 c = std::move(c0); 117 LIBCPP_ASSERT(c.bucket_count() == 7); 118 assert(c.size() == 6); 119 assert(c.count(1) == 2); 120 assert(c.count(2) == 2); 121 assert(c.count(3) == 1); 122 assert(c.count(4) == 1); 123 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 124 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 125 assert(c.get_allocator() == A(10)); 126 assert(!c.empty()); 127 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 128 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 129 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 130 assert(c.max_load_factor() == 1); 131 } 132 { 133 typedef other_allocator<int> A; 134 typedef std::unordered_multiset<int, 135 test_hash<std::hash<int> >, 136 test_compare<std::equal_to<int> >, 137 A 138 > C; 139 typedef int P; 140 P a[] = 141 { 142 P(1), 143 P(2), 144 P(3), 145 P(4), 146 P(1), 147 P(2) 148 }; 149 C c0(a, a + sizeof(a)/sizeof(a[0]), 150 7, 151 test_hash<std::hash<int> >(8), 152 test_compare<std::equal_to<int> >(9), 153 A(10) 154 ); 155 C c(a, a + 2, 156 7, 157 test_hash<std::hash<int> >(2), 158 test_compare<std::equal_to<int> >(3), 159 A(4) 160 ); 161 c = std::move(c0); 162 LIBCPP_ASSERT(c.bucket_count() == 7); 163 assert(c.size() == 6); 164 assert(c.count(1) == 2); 165 assert(c.count(2) == 2); 166 assert(c.count(3) == 1); 167 assert(c.count(4) == 1); 168 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 169 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 170 assert(c.get_allocator() == A(10)); 171 assert(!c.empty()); 172 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 173 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 174 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 175 assert(c.max_load_factor() == 1); 176 } 177 { 178 typedef test_allocator<int> A; 179 typedef std::unordered_multiset<int, 180 test_hash<std::hash<int> >, 181 test_compare<std::equal_to<int> >, 182 A 183 > C; 184 typedef int P; 185 P a[] = 186 { 187 P(1), 188 P(2), 189 P(3), 190 P(4), 191 P(1), 192 P(2) 193 }; 194 C c0(a, a + sizeof(a)/sizeof(a[0]), 195 7, 196 test_hash<std::hash<int> >(8), 197 test_compare<std::equal_to<int> >(9), 198 A() 199 ); 200 C c(a, a + 2, 201 7, 202 test_hash<std::hash<int> >(2), 203 test_compare<std::equal_to<int> >(3), 204 A() 205 ); 206 c = std::move(c0); 207 LIBCPP_ASSERT(c.bucket_count() == 7); 208 assert(c.size() == 6); 209 assert(c.count(1) == 2); 210 assert(c.count(2) == 2); 211 assert(c.count(3) == 1); 212 assert(c.count(4) == 1); 213 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 214 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 215 assert(c.get_allocator() == A()); 216 assert(!c.empty()); 217 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 218 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 219 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 220 assert(c.max_load_factor() == 1); 221 } 222 { 223 typedef min_allocator<int> A; 224 typedef std::unordered_multiset<int, 225 test_hash<std::hash<int> >, 226 test_compare<std::equal_to<int> >, 227 A 228 > C; 229 typedef int P; 230 P a[] = 231 { 232 P(1), 233 P(2), 234 P(3), 235 P(4), 236 P(1), 237 P(2) 238 }; 239 C c0(a, a + sizeof(a)/sizeof(a[0]), 240 7, 241 test_hash<std::hash<int> >(8), 242 test_compare<std::equal_to<int> >(9), 243 A() 244 ); 245 C c(a, a + 2, 246 7, 247 test_hash<std::hash<int> >(2), 248 test_compare<std::equal_to<int> >(3), 249 A() 250 ); 251 c = std::move(c0); 252 LIBCPP_ASSERT(c.bucket_count() == 7); 253 assert(c.size() == 6); 254 assert(c.count(1) == 2); 255 assert(c.count(2) == 2); 256 assert(c.count(3) == 1); 257 assert(c.count(4) == 1); 258 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 259 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 260 assert(c.get_allocator() == A()); 261 assert(!c.empty()); 262 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 263 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 264 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 265 assert(c.max_load_factor() == 1); 266 } 267 }