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 // <unordered_map> 11 12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13 // class Alloc = allocator<pair<const Key, T>>> 14 // class unordered_multimap 15 16 // void swap(unordered_multimap& __u); 17 18 #include <unordered_map> 19 #include <string> 20 #include <set> 21 #include <cassert> 22 #include <cstddef> 23 24 #include "test_macros.h" 25 #include "../../test_compare.h" 26 #include "../../test_hash.h" 27 #include "test_allocator.h" 28 29 #include "min_allocator.h" 30 31 int main() 32 { 33 { 34 typedef test_hash<std::hash<int> > Hash; 35 typedef test_compare<std::equal_to<int> > Compare; 36 typedef test_allocator<std::pair<const int, std::string> > Alloc; 37 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 38 C c1(0, Hash(1), Compare(1), Alloc(1, 1)); 39 C c2(0, Hash(2), Compare(2), Alloc(1, 2)); 40 c2.max_load_factor(2); 41 c1.swap(c2); 42 43 LIBCPP_ASSERT(c1.bucket_count() == 0); 44 assert(c1.size() == 0); 45 assert(c1.hash_function() == Hash(2)); 46 assert(c1.key_eq() == Compare(2)); 47 assert(c1.get_allocator().get_id() == 1); 48 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 49 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 50 assert(c1.max_load_factor() == 2); 51 52 LIBCPP_ASSERT(c2.bucket_count() == 0); 53 assert(c2.size() == 0); 54 assert(c2.hash_function() == Hash(1)); 55 assert(c2.key_eq() == Compare(1)); 56 assert(c2.get_allocator().get_id() == 2); 57 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 58 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 59 assert(c2.max_load_factor() == 1); 60 } 61 { 62 typedef test_hash<std::hash<int> > Hash; 63 typedef test_compare<std::equal_to<int> > Compare; 64 typedef test_allocator<std::pair<const int, std::string> > Alloc; 65 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 66 typedef std::pair<int, std::string> P; 67 P a2[] = 68 { 69 P(10, "ten"), 70 P(20, "twenty"), 71 P(30, "thirty"), 72 P(40, "forty"), 73 P(50, "fifty"), 74 P(60, "sixty"), 75 P(70, "seventy"), 76 P(80, "eighty"), 77 }; 78 C c1(0, Hash(1), Compare(1), Alloc(1, 1)); 79 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); 80 c2.max_load_factor(2); 81 c1.swap(c2); 82 83 assert(c1.bucket_count() >= 8); 84 assert(c1.size() == 8); 85 assert(c1.find(10)->second == "ten"); 86 assert(c1.find(20)->second == "twenty"); 87 assert(c1.find(30)->second == "thirty"); 88 assert(c1.find(40)->second == "forty"); 89 assert(c1.find(50)->second == "fifty"); 90 assert(c1.find(60)->second == "sixty"); 91 assert(c1.find(70)->second == "seventy"); 92 assert(c1.find(80)->second == "eighty"); 93 assert(c1.hash_function() == Hash(2)); 94 assert(c1.key_eq() == Compare(2)); 95 assert(c1.get_allocator().get_id() == 1); 96 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 97 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 98 assert(c1.max_load_factor() == 2); 99 100 LIBCPP_ASSERT(c2.bucket_count() == 0); 101 assert(c2.size() == 0); 102 assert(c2.hash_function() == Hash(1)); 103 assert(c2.key_eq() == Compare(1)); 104 assert(c2.get_allocator().get_id() == 2); 105 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 106 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 107 assert(c2.max_load_factor() == 1); 108 } 109 { 110 typedef test_hash<std::hash<int> > Hash; 111 typedef test_compare<std::equal_to<int> > Compare; 112 typedef test_allocator<std::pair<const int, std::string> > Alloc; 113 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 114 typedef std::pair<int, std::string> P; 115 P a1[] = 116 { 117 P(1, "one"), 118 P(2, "two"), 119 P(3, "three"), 120 P(4, "four"), 121 P(1, "four"), 122 P(2, "four"), 123 }; 124 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); 125 C c2(0, Hash(2), Compare(2), Alloc(1, 2)); 126 c2.max_load_factor(2); 127 c1.swap(c2); 128 129 LIBCPP_ASSERT(c1.bucket_count() == 0); 130 assert(c1.size() == 0); 131 assert(c1.hash_function() == Hash(2)); 132 assert(c1.key_eq() == Compare(2)); 133 assert(c1.get_allocator().get_id() == 1); 134 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 135 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 136 assert(c1.max_load_factor() == 2); 137 138 assert(c2.bucket_count() >= 6); 139 assert(c2.size() == 6); 140 { 141 std::set<std::string> s; 142 s.insert("one"); 143 s.insert("four"); 144 assert(s.find(c2.find(1)->second) != s.end()); 145 s.erase(s.find(c2.find(1)->second)); 146 assert(s.find(next(c2.find(1))->second) != s.end()); 147 } 148 { 149 std::set<std::string> s; 150 s.insert("two"); 151 s.insert("four"); 152 assert(s.find(c2.find(2)->second) != s.end()); 153 s.erase(s.find(c2.find(2)->second)); 154 assert(s.find(next(c2.find(2))->second) != s.end()); 155 } 156 assert(c2.find(3)->second == "three"); 157 assert(c2.find(4)->second == "four"); 158 assert(c2.hash_function() == Hash(1)); 159 assert(c2.key_eq() == Compare(1)); 160 assert(c2.get_allocator().get_id() == 2); 161 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 162 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 163 assert(c2.max_load_factor() == 1); 164 } 165 { 166 typedef test_hash<std::hash<int> > Hash; 167 typedef test_compare<std::equal_to<int> > Compare; 168 typedef test_allocator<std::pair<const int, std::string> > Alloc; 169 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 170 typedef std::pair<int, std::string> P; 171 P a1[] = 172 { 173 P(1, "one"), 174 P(2, "two"), 175 P(3, "three"), 176 P(4, "four"), 177 P(1, "four"), 178 P(2, "four"), 179 }; 180 P a2[] = 181 { 182 P(10, "ten"), 183 P(20, "twenty"), 184 P(30, "thirty"), 185 P(40, "forty"), 186 P(50, "fifty"), 187 P(60, "sixty"), 188 P(70, "seventy"), 189 P(80, "eighty"), 190 }; 191 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); 192 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); 193 c2.max_load_factor(2); 194 c1.swap(c2); 195 196 assert(c1.bucket_count() >= 8); 197 assert(c1.size() == 8); 198 assert(c1.find(10)->second == "ten"); 199 assert(c1.find(20)->second == "twenty"); 200 assert(c1.find(30)->second == "thirty"); 201 assert(c1.find(40)->second == "forty"); 202 assert(c1.find(50)->second == "fifty"); 203 assert(c1.find(60)->second == "sixty"); 204 assert(c1.find(70)->second == "seventy"); 205 assert(c1.find(80)->second == "eighty"); 206 assert(c1.hash_function() == Hash(2)); 207 assert(c1.key_eq() == Compare(2)); 208 assert(c1.get_allocator().get_id() == 1); 209 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 210 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 211 assert(c1.max_load_factor() == 2); 212 213 assert(c2.bucket_count() >= 6); 214 assert(c2.size() == 6); 215 { 216 std::set<std::string> s; 217 s.insert("one"); 218 s.insert("four"); 219 assert(s.find(c2.find(1)->second) != s.end()); 220 s.erase(s.find(c2.find(1)->second)); 221 assert(s.find(next(c2.find(1))->second) != s.end()); 222 } 223 { 224 std::set<std::string> s; 225 s.insert("two"); 226 s.insert("four"); 227 assert(s.find(c2.find(2)->second) != s.end()); 228 s.erase(s.find(c2.find(2)->second)); 229 assert(s.find(next(c2.find(2))->second) != s.end()); 230 } 231 assert(c2.find(3)->second == "three"); 232 assert(c2.find(4)->second == "four"); 233 assert(c2.hash_function() == Hash(1)); 234 assert(c2.key_eq() == Compare(1)); 235 assert(c2.get_allocator().get_id() == 2); 236 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 237 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 238 assert(c2.max_load_factor() == 1); 239 } 240 241 { 242 typedef test_hash<std::hash<int> > Hash; 243 typedef test_compare<std::equal_to<int> > Compare; 244 typedef other_allocator<std::pair<const int, std::string> > Alloc; 245 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 246 C c1(0, Hash(1), Compare(1), Alloc(1)); 247 C c2(0, Hash(2), Compare(2), Alloc(2)); 248 c2.max_load_factor(2); 249 c1.swap(c2); 250 251 LIBCPP_ASSERT(c1.bucket_count() == 0); 252 assert(c1.size() == 0); 253 assert(c1.hash_function() == Hash(2)); 254 assert(c1.key_eq() == Compare(2)); 255 assert(c1.get_allocator() == Alloc(2)); 256 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 257 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 258 assert(c1.max_load_factor() == 2); 259 260 LIBCPP_ASSERT(c2.bucket_count() == 0); 261 assert(c2.size() == 0); 262 assert(c2.hash_function() == Hash(1)); 263 assert(c2.key_eq() == Compare(1)); 264 assert(c2.get_allocator() == Alloc(1)); 265 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 266 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 267 assert(c2.max_load_factor() == 1); 268 } 269 { 270 typedef test_hash<std::hash<int> > Hash; 271 typedef test_compare<std::equal_to<int> > Compare; 272 typedef other_allocator<std::pair<const int, std::string> > Alloc; 273 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 274 typedef std::pair<int, std::string> P; 275 P a2[] = 276 { 277 P(10, "ten"), 278 P(20, "twenty"), 279 P(30, "thirty"), 280 P(40, "forty"), 281 P(50, "fifty"), 282 P(60, "sixty"), 283 P(70, "seventy"), 284 P(80, "eighty"), 285 }; 286 C c1(0, Hash(1), Compare(1), Alloc(1)); 287 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 288 c2.max_load_factor(2); 289 c1.swap(c2); 290 291 assert(c1.bucket_count() >= 8); 292 assert(c1.size() == 8); 293 assert(c1.find(10)->second == "ten"); 294 assert(c1.find(20)->second == "twenty"); 295 assert(c1.find(30)->second == "thirty"); 296 assert(c1.find(40)->second == "forty"); 297 assert(c1.find(50)->second == "fifty"); 298 assert(c1.find(60)->second == "sixty"); 299 assert(c1.find(70)->second == "seventy"); 300 assert(c1.find(80)->second == "eighty"); 301 assert(c1.hash_function() == Hash(2)); 302 assert(c1.key_eq() == Compare(2)); 303 assert(c1.get_allocator() == Alloc(2)); 304 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 305 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 306 assert(c1.max_load_factor() == 2); 307 308 LIBCPP_ASSERT(c2.bucket_count() == 0); 309 assert(c2.size() == 0); 310 assert(c2.hash_function() == Hash(1)); 311 assert(c2.key_eq() == Compare(1)); 312 assert(c2.get_allocator() == Alloc(1)); 313 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 314 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 315 assert(c2.max_load_factor() == 1); 316 } 317 { 318 typedef test_hash<std::hash<int> > Hash; 319 typedef test_compare<std::equal_to<int> > Compare; 320 typedef other_allocator<std::pair<const int, std::string> > Alloc; 321 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 322 typedef std::pair<int, std::string> P; 323 P a1[] = 324 { 325 P(1, "one"), 326 P(2, "two"), 327 P(3, "three"), 328 P(4, "four"), 329 P(1, "four"), 330 P(2, "four"), 331 }; 332 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 333 C c2(0, Hash(2), Compare(2), Alloc(2)); 334 c2.max_load_factor(2); 335 c1.swap(c2); 336 337 LIBCPP_ASSERT(c1.bucket_count() == 0); 338 assert(c1.size() == 0); 339 assert(c1.hash_function() == Hash(2)); 340 assert(c1.key_eq() == Compare(2)); 341 assert(c1.get_allocator() == Alloc(2)); 342 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 343 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 344 assert(c1.max_load_factor() == 2); 345 346 assert(c2.bucket_count() >= 6); 347 assert(c2.size() == 6); 348 { 349 std::set<std::string> s; 350 s.insert("one"); 351 s.insert("four"); 352 assert(s.find(c2.find(1)->second) != s.end()); 353 s.erase(s.find(c2.find(1)->second)); 354 assert(s.find(next(c2.find(1))->second) != s.end()); 355 } 356 { 357 std::set<std::string> s; 358 s.insert("two"); 359 s.insert("four"); 360 assert(s.find(c2.find(2)->second) != s.end()); 361 s.erase(s.find(c2.find(2)->second)); 362 assert(s.find(next(c2.find(2))->second) != s.end()); 363 } 364 assert(c2.find(3)->second == "three"); 365 assert(c2.find(4)->second == "four"); 366 assert(c2.hash_function() == Hash(1)); 367 assert(c2.key_eq() == Compare(1)); 368 assert(c2.get_allocator() == Alloc(1)); 369 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 370 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 371 assert(c2.max_load_factor() == 1); 372 } 373 { 374 typedef test_hash<std::hash<int> > Hash; 375 typedef test_compare<std::equal_to<int> > Compare; 376 typedef other_allocator<std::pair<const int, std::string> > Alloc; 377 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 378 typedef std::pair<int, std::string> P; 379 P a1[] = 380 { 381 P(1, "one"), 382 P(2, "two"), 383 P(3, "three"), 384 P(4, "four"), 385 P(1, "four"), 386 P(2, "four"), 387 }; 388 P a2[] = 389 { 390 P(10, "ten"), 391 P(20, "twenty"), 392 P(30, "thirty"), 393 P(40, "forty"), 394 P(50, "fifty"), 395 P(60, "sixty"), 396 P(70, "seventy"), 397 P(80, "eighty"), 398 }; 399 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 400 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 401 c2.max_load_factor(2); 402 c1.swap(c2); 403 404 assert(c1.bucket_count() >= 8); 405 assert(c1.size() == 8); 406 assert(c1.find(10)->second == "ten"); 407 assert(c1.find(20)->second == "twenty"); 408 assert(c1.find(30)->second == "thirty"); 409 assert(c1.find(40)->second == "forty"); 410 assert(c1.find(50)->second == "fifty"); 411 assert(c1.find(60)->second == "sixty"); 412 assert(c1.find(70)->second == "seventy"); 413 assert(c1.find(80)->second == "eighty"); 414 assert(c1.hash_function() == Hash(2)); 415 assert(c1.key_eq() == Compare(2)); 416 assert(c1.get_allocator() == Alloc(2)); 417 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 418 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 419 assert(c1.max_load_factor() == 2); 420 421 assert(c2.bucket_count() >= 6); 422 assert(c2.size() == 6); 423 { 424 std::set<std::string> s; 425 s.insert("one"); 426 s.insert("four"); 427 assert(s.find(c2.find(1)->second) != s.end()); 428 s.erase(s.find(c2.find(1)->second)); 429 assert(s.find(next(c2.find(1))->second) != s.end()); 430 } 431 { 432 std::set<std::string> s; 433 s.insert("two"); 434 s.insert("four"); 435 assert(s.find(c2.find(2)->second) != s.end()); 436 s.erase(s.find(c2.find(2)->second)); 437 assert(s.find(next(c2.find(2))->second) != s.end()); 438 } 439 assert(c2.find(3)->second == "three"); 440 assert(c2.find(4)->second == "four"); 441 assert(c2.hash_function() == Hash(1)); 442 assert(c2.key_eq() == Compare(1)); 443 assert(c2.get_allocator() == Alloc(1)); 444 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 445 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 446 assert(c2.max_load_factor() == 1); 447 } 448 #if TEST_STD_VER >= 11 449 { 450 typedef test_hash<std::hash<int> > Hash; 451 typedef test_compare<std::equal_to<int> > Compare; 452 typedef min_allocator<std::pair<const int, std::string> > Alloc; 453 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 454 C c1(0, Hash(1), Compare(1), Alloc()); 455 C c2(0, Hash(2), Compare(2), Alloc()); 456 c2.max_load_factor(2); 457 c1.swap(c2); 458 459 LIBCPP_ASSERT(c1.bucket_count() == 0); 460 assert(c1.size() == 0); 461 assert(c1.hash_function() == Hash(2)); 462 assert(c1.key_eq() == Compare(2)); 463 assert(c1.get_allocator() == Alloc()); 464 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 465 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 466 assert(c1.max_load_factor() == 2); 467 468 LIBCPP_ASSERT(c2.bucket_count() == 0); 469 assert(c2.size() == 0); 470 assert(c2.hash_function() == Hash(1)); 471 assert(c2.key_eq() == Compare(1)); 472 assert(c2.get_allocator() == Alloc()); 473 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 474 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 475 assert(c2.max_load_factor() == 1); 476 } 477 { 478 typedef test_hash<std::hash<int> > Hash; 479 typedef test_compare<std::equal_to<int> > Compare; 480 typedef min_allocator<std::pair<const int, std::string> > Alloc; 481 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 482 typedef std::pair<int, std::string> P; 483 P a2[] = 484 { 485 P(10, "ten"), 486 P(20, "twenty"), 487 P(30, "thirty"), 488 P(40, "forty"), 489 P(50, "fifty"), 490 P(60, "sixty"), 491 P(70, "seventy"), 492 P(80, "eighty"), 493 }; 494 C c1(0, Hash(1), Compare(1), Alloc()); 495 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 496 c2.max_load_factor(2); 497 c1.swap(c2); 498 499 assert(c1.bucket_count() >= 8); 500 assert(c1.size() == 8); 501 assert(c1.find(10)->second == "ten"); 502 assert(c1.find(20)->second == "twenty"); 503 assert(c1.find(30)->second == "thirty"); 504 assert(c1.find(40)->second == "forty"); 505 assert(c1.find(50)->second == "fifty"); 506 assert(c1.find(60)->second == "sixty"); 507 assert(c1.find(70)->second == "seventy"); 508 assert(c1.find(80)->second == "eighty"); 509 assert(c1.hash_function() == Hash(2)); 510 assert(c1.key_eq() == Compare(2)); 511 assert(c1.get_allocator() == Alloc()); 512 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 513 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 514 assert(c1.max_load_factor() == 2); 515 516 LIBCPP_ASSERT(c2.bucket_count() == 0); 517 assert(c2.size() == 0); 518 assert(c2.hash_function() == Hash(1)); 519 assert(c2.key_eq() == Compare(1)); 520 assert(c2.get_allocator() == Alloc()); 521 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 522 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 523 assert(c2.max_load_factor() == 1); 524 } 525 { 526 typedef test_hash<std::hash<int> > Hash; 527 typedef test_compare<std::equal_to<int> > Compare; 528 typedef min_allocator<std::pair<const int, std::string> > Alloc; 529 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 530 typedef std::pair<int, std::string> P; 531 P a1[] = 532 { 533 P(1, "one"), 534 P(2, "two"), 535 P(3, "three"), 536 P(4, "four"), 537 P(1, "four"), 538 P(2, "four"), 539 }; 540 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 541 C c2(0, Hash(2), Compare(2), Alloc()); 542 c2.max_load_factor(2); 543 c1.swap(c2); 544 545 LIBCPP_ASSERT(c1.bucket_count() == 0); 546 assert(c1.size() == 0); 547 assert(c1.hash_function() == Hash(2)); 548 assert(c1.key_eq() == Compare(2)); 549 assert(c1.get_allocator() == Alloc()); 550 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 551 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 552 assert(c1.max_load_factor() == 2); 553 554 assert(c2.bucket_count() >= 6); 555 assert(c2.size() == 6); 556 { 557 std::set<std::string> s; 558 s.insert("one"); 559 s.insert("four"); 560 assert(s.find(c2.find(1)->second) != s.end()); 561 s.erase(s.find(c2.find(1)->second)); 562 assert(s.find(next(c2.find(1))->second) != s.end()); 563 } 564 { 565 std::set<std::string> s; 566 s.insert("two"); 567 s.insert("four"); 568 assert(s.find(c2.find(2)->second) != s.end()); 569 s.erase(s.find(c2.find(2)->second)); 570 assert(s.find(next(c2.find(2))->second) != s.end()); 571 } 572 assert(c2.find(3)->second == "three"); 573 assert(c2.find(4)->second == "four"); 574 assert(c2.hash_function() == Hash(1)); 575 assert(c2.key_eq() == Compare(1)); 576 assert(c2.get_allocator() == Alloc()); 577 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 578 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 579 assert(c2.max_load_factor() == 1); 580 } 581 { 582 typedef test_hash<std::hash<int> > Hash; 583 typedef test_compare<std::equal_to<int> > Compare; 584 typedef min_allocator<std::pair<const int, std::string> > Alloc; 585 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 586 typedef std::pair<int, std::string> P; 587 P a1[] = 588 { 589 P(1, "one"), 590 P(2, "two"), 591 P(3, "three"), 592 P(4, "four"), 593 P(1, "four"), 594 P(2, "four"), 595 }; 596 P a2[] = 597 { 598 P(10, "ten"), 599 P(20, "twenty"), 600 P(30, "thirty"), 601 P(40, "forty"), 602 P(50, "fifty"), 603 P(60, "sixty"), 604 P(70, "seventy"), 605 P(80, "eighty"), 606 }; 607 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 608 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 609 c2.max_load_factor(2); 610 c1.swap(c2); 611 612 assert(c1.bucket_count() >= 8); 613 assert(c1.size() == 8); 614 assert(c1.find(10)->second == "ten"); 615 assert(c1.find(20)->second == "twenty"); 616 assert(c1.find(30)->second == "thirty"); 617 assert(c1.find(40)->second == "forty"); 618 assert(c1.find(50)->second == "fifty"); 619 assert(c1.find(60)->second == "sixty"); 620 assert(c1.find(70)->second == "seventy"); 621 assert(c1.find(80)->second == "eighty"); 622 assert(c1.hash_function() == Hash(2)); 623 assert(c1.key_eq() == Compare(2)); 624 assert(c1.get_allocator() == Alloc()); 625 assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 626 assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); 627 assert(c1.max_load_factor() == 2); 628 629 assert(c2.bucket_count() >= 6); 630 assert(c2.size() == 6); 631 { 632 std::set<std::string> s; 633 s.insert("one"); 634 s.insert("four"); 635 assert(s.find(c2.find(1)->second) != s.end()); 636 s.erase(s.find(c2.find(1)->second)); 637 assert(s.find(next(c2.find(1))->second) != s.end()); 638 } 639 { 640 std::set<std::string> s; 641 s.insert("two"); 642 s.insert("four"); 643 assert(s.find(c2.find(2)->second) != s.end()); 644 s.erase(s.find(c2.find(2)->second)); 645 assert(s.find(next(c2.find(2))->second) != s.end()); 646 } 647 assert(c2.find(3)->second == "three"); 648 assert(c2.find(4)->second == "four"); 649 assert(c2.hash_function() == Hash(1)); 650 assert(c2.key_eq() == Compare(1)); 651 assert(c2.get_allocator() == Alloc()); 652 assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 653 assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); 654 assert(c2.max_load_factor() == 1); 655 } 656 #endif 657 } 658
