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 22 #include "../../../test_compare.h" 23 #include "../../../test_hash.h" 24 #include "test_allocator.h" 25 #include "min_allocator.h" 26 27 int main() 28 { 29 { 30 typedef test_hash<std::hash<int> > Hash; 31 typedef test_compare<std::equal_to<int> > Compare; 32 typedef test_allocator<std::pair<const int, std::string> > Alloc; 33 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 34 typedef std::pair<int, std::string> P; 35 C c1(0, Hash(1), Compare(1), Alloc(1)); 36 C c2(0, Hash(2), Compare(2), Alloc(2)); 37 c2.max_load_factor(2); 38 swap(c1, c2); 39 40 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() == Alloc(1)); 45 assert(std::distance(c1.begin(), c1.end()) == c1.size()); 46 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 47 assert(c1.max_load_factor() == 2); 48 49 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() == Alloc(2)); 54 assert(std::distance(c2.begin(), c2.end()) == c2.size()); 55 assert(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<std::pair<const int, std::string> > Alloc; 62 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 63 typedef std::pair<int, std::string> P; 64 P a2[] = 65 { 66 P(10, "ten"), 67 P(20, "twenty"), 68 P(30, "thirty"), 69 P(40, "fourty"), 70 P(50, "fifty"), 71 P(60, "sixty"), 72 P(70, "seventy"), 73 P(80, "eighty"), 74 }; 75 C c1(0, Hash(1), Compare(1), Alloc(1)); 76 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 77 c2.max_load_factor(2); 78 swap(c1, c2); 79 80 assert(c1.bucket_count() >= 11); 81 assert(c1.size() == 8); 82 assert(c1.find(10)->second == "ten"); 83 assert(c1.find(20)->second == "twenty"); 84 assert(c1.find(30)->second == "thirty"); 85 assert(c1.find(40)->second == "fourty"); 86 assert(c1.find(50)->second == "fifty"); 87 assert(c1.find(60)->second == "sixty"); 88 assert(c1.find(70)->second == "seventy"); 89 assert(c1.find(80)->second == "eighty"); 90 assert(c1.hash_function() == Hash(2)); 91 assert(c1.key_eq() == Compare(2)); 92 assert(c1.get_allocator() == Alloc(1)); 93 assert(std::distance(c1.begin(), c1.end()) == c1.size()); 94 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 95 assert(c1.max_load_factor() == 2); 96 97 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() == Alloc(2)); 102 assert(std::distance(c2.begin(), c2.end()) == c2.size()); 103 assert(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<std::pair<const int, std::string> > Alloc; 110 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 111 typedef std::pair<int, std::string> P; 112 P a1[] = 113 { 114 P(1, "one"), 115 P(2, "two"), 116 P(3, "three"), 117 P(4, "four"), 118 P(1, "four"), 119 P(2, "four"), 120 }; 121 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 122 C c2(0, Hash(2), Compare(2), Alloc(2)); 123 c2.max_load_factor(2); 124 swap(c1, c2); 125 126 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() == Alloc(1)); 131 assert(std::distance(c1.begin(), c1.end()) == c1.size()); 132 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 133 assert(c1.max_load_factor() == 2); 134 135 assert(c2.bucket_count() >= 7); 136 assert(c2.size() == 6); 137 assert(c2.find(1)->second == "one"); 138 assert(next(c2.find(1))->second == "four"); 139 assert(c2.find(2)->second == "two"); 140 assert(next(c2.find(2))->second == "four"); 141 assert(c2.find(3)->second == "three"); 142 assert(c2.find(4)->second == "four"); 143 assert(c2.hash_function() == Hash(1)); 144 assert(c2.key_eq() == Compare(1)); 145 assert(c2.get_allocator() == Alloc(2)); 146 assert(std::distance(c2.begin(), c2.end()) == c2.size()); 147 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 148 assert(c2.max_load_factor() == 1); 149 } 150 { 151 typedef test_hash<std::hash<int> > Hash; 152 typedef test_compare<std::equal_to<int> > Compare; 153 typedef test_allocator<std::pair<const int, std::string> > Alloc; 154 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 155 typedef std::pair<int, std::string> P; 156 P a1[] = 157 { 158 P(1, "one"), 159 P(2, "two"), 160 P(3, "three"), 161 P(4, "four"), 162 P(1, "four"), 163 P(2, "four"), 164 }; 165 P a2[] = 166 { 167 P(10, "ten"), 168 P(20, "twenty"), 169 P(30, "thirty"), 170 P(40, "fourty"), 171 P(50, "fifty"), 172 P(60, "sixty"), 173 P(70, "seventy"), 174 P(80, "eighty"), 175 }; 176 C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 177 C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 178 c2.max_load_factor(2); 179 swap(c1, c2); 180 181 assert(c1.bucket_count() >= 11); 182 assert(c1.size() == 8); 183 assert(c1.find(10)->second == "ten"); 184 assert(c1.find(20)->second == "twenty"); 185 assert(c1.find(30)->second == "thirty"); 186 assert(c1.find(40)->second == "fourty"); 187 assert(c1.find(50)->second == "fifty"); 188 assert(c1.find(60)->second == "sixty"); 189 assert(c1.find(70)->second == "seventy"); 190 assert(c1.find(80)->second == "eighty"); 191 assert(c1.hash_function() == Hash(2)); 192 assert(c1.key_eq() == Compare(2)); 193 assert(c1.get_allocator() == Alloc(1)); 194 assert(std::distance(c1.begin(), c1.end()) == c1.size()); 195 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 196 assert(c1.max_load_factor() == 2); 197 198 assert(c2.bucket_count() >= 7); 199 assert(c2.size() == 6); 200 assert(c2.find(1)->second == "one"); 201 assert(next(c2.find(1))->second == "four"); 202 assert(c2.find(2)->second == "two"); 203 assert(next(c2.find(2))->second == "four"); 204 assert(c2.find(3)->second == "three"); 205 assert(c2.find(4)->second == "four"); 206 assert(c2.hash_function() == Hash(1)); 207 assert(c2.key_eq() == Compare(1)); 208 assert(c2.get_allocator() == Alloc(2)); 209 assert(std::distance(c2.begin(), c2.end()) == c2.size()); 210 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 211 assert(c2.max_load_factor() == 1); 212 } 213 214 { 215 typedef test_hash<std::hash<int> > Hash; 216 typedef test_compare<std::equal_to<int> > Compare; 217 typedef other_allocator<std::pair<const int, std::string> > Alloc; 218 typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 219 typedef std::pair<int, std::string> P; 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 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(std::distance(c1.begin(), c1.end()) == c1.size()); 231 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 232 assert(c1.max_load_factor() == 2); 233 234 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(std::distance(c2.begin(), c2.end()) == c2.size()); 240 assert(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, "fourty"), 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() >= 11); 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 == "fourty"); 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(std::distance(c1.begin(), c1.end()) == c1.size()); 279 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 280 assert(c1.max_load_factor() == 2); 281 282 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(std::distance(c2.begin(), c2.end()) == c2.size()); 288 assert(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 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(std::distance(c1.begin(), c1.end()) == c1.size()); 317 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 318 assert(c1.max_load_factor() == 2); 319 320 assert(c2.bucket_count() >= 7); 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(std::distance(c2.begin(), c2.end()) == c2.size()); 332 assert(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, "fourty"), 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() >= 11); 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 == "fourty"); 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(std::distance(c1.begin(), c1.end()) == c1.size()); 380 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 381 assert(c1.max_load_factor() == 2); 382 383 assert(c2.bucket_count() >= 7); 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(std::distance(c2.begin(), c2.end()) == c2.size()); 395 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 396 assert(c2.max_load_factor() == 1); 397 } 398 #if __cplusplus >= 201103L 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 typedef std::pair<int, std::string> P; 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 swap(c1, c2); 409 410 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(std::distance(c1.begin(), c1.end()) == c1.size()); 416 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 417 assert(c1.max_load_factor() == 2); 418 419 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(std::distance(c2.begin(), c2.end()) == c2.size()); 425 assert(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, "fourty"), 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 swap(c1, c2); 449 450 assert(c1.bucket_count() >= 11); 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 == "fourty"); 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(std::distance(c1.begin(), c1.end()) == c1.size()); 464 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 465 assert(c1.max_load_factor() == 2); 466 467 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(std::distance(c2.begin(), c2.end()) == c2.size()); 473 assert(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 swap(c1, c2); 495 496 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(std::distance(c1.begin(), c1.end()) == c1.size()); 502 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 503 assert(c1.max_load_factor() == 2); 504 505 assert(c2.bucket_count() >= 7); 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(std::distance(c2.begin(), c2.end()) == c2.size()); 517 assert(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, "fourty"), 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 swap(c1, c2); 550 551 assert(c1.bucket_count() >= 11); 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 == "fourty"); 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(std::distance(c1.begin(), c1.end()) == c1.size()); 565 assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 566 assert(c1.max_load_factor() == 2); 567 568 assert(c2.bucket_count() >= 7); 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(std::distance(c2.begin(), c2.end()) == c2.size()); 580 assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 581 assert(c2.max_load_factor() == 1); 582 } 583 #endif 584 } 585
