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