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