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