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 // <list> 11 12 // void splice(const_iterator position, list& x); 13 14 #if _LIBCPP_DEBUG >= 1 15 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) 16 #endif 17 18 #include <list> 19 #include <cassert> 20 21 #include "min_allocator.h" 22 23 int main() 24 { 25 int a1[] = {1, 2, 3}; 26 int a2[] = {4, 5, 6}; 27 { 28 std::list<int> l1; 29 std::list<int> l2; 30 l1.splice(l1.end(), l2); 31 assert(l1.size() == 0); 32 assert(distance(l1.begin(), l1.end()) == 0); 33 assert(l2.size() == 0); 34 assert(distance(l2.begin(), l2.end()) == 0); 35 } 36 { 37 std::list<int> l1; 38 std::list<int> l2(a2, a2+1); 39 l1.splice(l1.end(), l2); 40 assert(l1.size() == 1); 41 assert(distance(l1.begin(), l1.end()) == 1); 42 assert(l2.size() == 0); 43 assert(distance(l2.begin(), l2.end()) == 0); 44 std::list<int>::const_iterator i = l1.begin(); 45 assert(*i == 4); 46 } 47 { 48 std::list<int> l1; 49 std::list<int> l2(a2, a2+2); 50 l1.splice(l1.end(), l2); 51 assert(l1.size() == 2); 52 assert(distance(l1.begin(), l1.end()) == 2); 53 assert(l2.size() == 0); 54 assert(distance(l2.begin(), l2.end()) == 0); 55 std::list<int>::const_iterator i = l1.begin(); 56 assert(*i == 4); 57 ++i; 58 assert(*i == 5); 59 } 60 { 61 std::list<int> l1; 62 std::list<int> l2(a2, a2+3); 63 l1.splice(l1.end(), l2); 64 assert(l1.size() == 3); 65 assert(distance(l1.begin(), l1.end()) == 3); 66 assert(l2.size() == 0); 67 assert(distance(l2.begin(), l2.end()) == 0); 68 std::list<int>::const_iterator i = l1.begin(); 69 assert(*i == 4); 70 ++i; 71 assert(*i == 5); 72 ++i; 73 assert(*i == 6); 74 } 75 { 76 std::list<int> l1(a1, a1+1); 77 std::list<int> l2; 78 l1.splice(l1.begin(), l2); 79 assert(l1.size() == 1); 80 assert(distance(l1.begin(), l1.end()) == 1); 81 assert(l2.size() == 0); 82 assert(distance(l2.begin(), l2.end()) == 0); 83 std::list<int>::const_iterator i = l1.begin(); 84 assert(*i == 1); 85 } 86 { 87 std::list<int> l1(a1, a1+1); 88 std::list<int> l2; 89 l1.splice(l1.end(), l2); 90 assert(l1.size() == 1); 91 assert(distance(l1.begin(), l1.end()) == 1); 92 assert(l2.size() == 0); 93 assert(distance(l2.begin(), l2.end()) == 0); 94 std::list<int>::const_iterator i = l1.begin(); 95 assert(*i == 1); 96 } 97 { 98 std::list<int> l1(a1, a1+1); 99 std::list<int> l2(a2, a2+1); 100 l1.splice(l1.begin(), l2); 101 assert(l1.size() == 2); 102 assert(distance(l1.begin(), l1.end()) == 2); 103 assert(l2.size() == 0); 104 assert(distance(l2.begin(), l2.end()) == 0); 105 std::list<int>::const_iterator i = l1.begin(); 106 assert(*i == 4); 107 ++i; 108 assert(*i == 1); 109 } 110 { 111 std::list<int> l1(a1, a1+1); 112 std::list<int> l2(a2, a2+1); 113 l1.splice(l1.end(), l2); 114 assert(l1.size() == 2); 115 assert(distance(l1.begin(), l1.end()) == 2); 116 assert(l2.size() == 0); 117 assert(distance(l2.begin(), l2.end()) == 0); 118 std::list<int>::const_iterator i = l1.begin(); 119 assert(*i == 1); 120 ++i; 121 assert(*i == 4); 122 } 123 { 124 std::list<int> l1(a1, a1+1); 125 std::list<int> l2(a2, a2+2); 126 l1.splice(l1.begin(), l2); 127 assert(l1.size() == 3); 128 assert(distance(l1.begin(), l1.end()) == 3); 129 assert(l2.size() == 0); 130 assert(distance(l2.begin(), l2.end()) == 0); 131 std::list<int>::const_iterator i = l1.begin(); 132 assert(*i == 4); 133 ++i; 134 assert(*i == 5); 135 ++i; 136 assert(*i == 1); 137 } 138 { 139 std::list<int> l1(a1, a1+1); 140 std::list<int> l2(a2, a2+2); 141 l1.splice(l1.end(), l2); 142 assert(l1.size() == 3); 143 assert(distance(l1.begin(), l1.end()) == 3); 144 assert(l2.size() == 0); 145 assert(distance(l2.begin(), l2.end()) == 0); 146 std::list<int>::const_iterator i = l1.begin(); 147 assert(*i == 1); 148 ++i; 149 assert(*i == 4); 150 ++i; 151 assert(*i == 5); 152 } 153 { 154 std::list<int> l1(a1, a1+1); 155 std::list<int> l2(a2, a2+3); 156 l1.splice(l1.begin(), l2); 157 assert(l1.size() == 4); 158 assert(distance(l1.begin(), l1.end()) == 4); 159 assert(l2.size() == 0); 160 assert(distance(l2.begin(), l2.end()) == 0); 161 std::list<int>::const_iterator i = l1.begin(); 162 assert(*i == 4); 163 ++i; 164 assert(*i == 5); 165 ++i; 166 assert(*i == 6); 167 ++i; 168 assert(*i == 1); 169 } 170 { 171 std::list<int> l1(a1, a1+1); 172 std::list<int> l2(a2, a2+3); 173 l1.splice(l1.end(), l2); 174 assert(l1.size() == 4); 175 assert(distance(l1.begin(), l1.end()) == 4); 176 assert(l2.size() == 0); 177 assert(distance(l2.begin(), l2.end()) == 0); 178 std::list<int>::const_iterator i = l1.begin(); 179 assert(*i == 1); 180 ++i; 181 assert(*i == 4); 182 ++i; 183 assert(*i == 5); 184 ++i; 185 assert(*i == 6); 186 } 187 { 188 std::list<int> l1(a1, a1+2); 189 std::list<int> l2; 190 l1.splice(l1.begin(), l2); 191 assert(l1.size() == 2); 192 assert(distance(l1.begin(), l1.end()) == 2); 193 assert(l2.size() == 0); 194 assert(distance(l2.begin(), l2.end()) == 0); 195 std::list<int>::const_iterator i = l1.begin(); 196 assert(*i == 1); 197 ++i; 198 assert(*i == 2); 199 } 200 { 201 std::list<int> l1(a1, a1+2); 202 std::list<int> l2; 203 l1.splice(next(l1.begin()), l2); 204 assert(l1.size() == 2); 205 assert(distance(l1.begin(), l1.end()) == 2); 206 assert(l2.size() == 0); 207 assert(distance(l2.begin(), l2.end()) == 0); 208 std::list<int>::const_iterator i = l1.begin(); 209 assert(*i == 1); 210 ++i; 211 assert(*i == 2); 212 } 213 { 214 std::list<int> l1(a1, a1+2); 215 std::list<int> l2; 216 l1.splice(next(l1.begin(), 2), l2); 217 assert(l1.size() == 2); 218 assert(distance(l1.begin(), l1.end()) == 2); 219 assert(l2.size() == 0); 220 assert(distance(l2.begin(), l2.end()) == 0); 221 std::list<int>::const_iterator i = l1.begin(); 222 assert(*i == 1); 223 ++i; 224 assert(*i == 2); 225 } 226 { 227 std::list<int> l1(a1, a1+2); 228 std::list<int> l2(a2, a2+1); 229 l1.splice(l1.begin(), l2); 230 assert(l1.size() == 3); 231 assert(distance(l1.begin(), l1.end()) == 3); 232 assert(l2.size() == 0); 233 assert(distance(l2.begin(), l2.end()) == 0); 234 std::list<int>::const_iterator i = l1.begin(); 235 assert(*i == 4); 236 ++i; 237 assert(*i == 1); 238 ++i; 239 assert(*i == 2); 240 } 241 { 242 std::list<int> l1(a1, a1+2); 243 std::list<int> l2(a2, a2+1); 244 l1.splice(next(l1.begin()), l2); 245 assert(l1.size() == 3); 246 assert(distance(l1.begin(), l1.end()) == 3); 247 assert(l2.size() == 0); 248 assert(distance(l2.begin(), l2.end()) == 0); 249 std::list<int>::const_iterator i = l1.begin(); 250 assert(*i == 1); 251 ++i; 252 assert(*i == 4); 253 ++i; 254 assert(*i == 2); 255 } 256 { 257 std::list<int> l1(a1, a1+2); 258 std::list<int> l2(a2, a2+1); 259 l1.splice(next(l1.begin(), 2), l2); 260 assert(l1.size() == 3); 261 assert(distance(l1.begin(), l1.end()) == 3); 262 assert(l2.size() == 0); 263 assert(distance(l2.begin(), l2.end()) == 0); 264 std::list<int>::const_iterator i = l1.begin(); 265 assert(*i == 1); 266 ++i; 267 assert(*i == 2); 268 ++i; 269 assert(*i == 4); 270 } 271 { 272 std::list<int> l1(a1, a1+2); 273 std::list<int> l2(a2, a2+2); 274 l1.splice(l1.begin(), l2); 275 assert(l1.size() == 4); 276 assert(distance(l1.begin(), l1.end()) == 4); 277 assert(l2.size() == 0); 278 assert(distance(l2.begin(), l2.end()) == 0); 279 std::list<int>::const_iterator i = l1.begin(); 280 assert(*i == 4); 281 ++i; 282 assert(*i == 5); 283 ++i; 284 assert(*i == 1); 285 ++i; 286 assert(*i == 2); 287 } 288 { 289 std::list<int> l1(a1, a1+2); 290 std::list<int> l2(a2, a2+2); 291 l1.splice(next(l1.begin()), l2); 292 assert(l1.size() == 4); 293 assert(distance(l1.begin(), l1.end()) == 4); 294 assert(l2.size() == 0); 295 assert(distance(l2.begin(), l2.end()) == 0); 296 std::list<int>::const_iterator i = l1.begin(); 297 assert(*i == 1); 298 ++i; 299 assert(*i == 4); 300 ++i; 301 assert(*i == 5); 302 ++i; 303 assert(*i == 2); 304 } 305 { 306 std::list<int> l1(a1, a1+2); 307 std::list<int> l2(a2, a2+2); 308 l1.splice(next(l1.begin(), 2), l2); 309 assert(l1.size() == 4); 310 assert(distance(l1.begin(), l1.end()) == 4); 311 assert(l2.size() == 0); 312 assert(distance(l2.begin(), l2.end()) == 0); 313 std::list<int>::const_iterator i = l1.begin(); 314 assert(*i == 1); 315 ++i; 316 assert(*i == 2); 317 ++i; 318 assert(*i == 4); 319 ++i; 320 assert(*i == 5); 321 } 322 { 323 std::list<int> l1(a1, a1+3); 324 std::list<int> l2(a2, a2+3); 325 l1.splice(l1.begin(), l2); 326 assert(l1.size() == 6); 327 assert(distance(l1.begin(), l1.end()) == 6); 328 assert(l2.size() == 0); 329 assert(distance(l2.begin(), l2.end()) == 0); 330 std::list<int>::const_iterator i = l1.begin(); 331 assert(*i == 4); 332 ++i; 333 assert(*i == 5); 334 ++i; 335 assert(*i == 6); 336 ++i; 337 assert(*i == 1); 338 ++i; 339 assert(*i == 2); 340 ++i; 341 assert(*i == 3); 342 } 343 { 344 std::list<int> l1(a1, a1+3); 345 std::list<int> l2(a2, a2+3); 346 l1.splice(next(l1.begin()), l2); 347 assert(l1.size() == 6); 348 assert(distance(l1.begin(), l1.end()) == 6); 349 assert(l2.size() == 0); 350 assert(distance(l2.begin(), l2.end()) == 0); 351 std::list<int>::const_iterator i = l1.begin(); 352 assert(*i == 1); 353 ++i; 354 assert(*i == 4); 355 ++i; 356 assert(*i == 5); 357 ++i; 358 assert(*i == 6); 359 ++i; 360 assert(*i == 2); 361 ++i; 362 assert(*i == 3); 363 } 364 { 365 std::list<int> l1(a1, a1+3); 366 std::list<int> l2(a2, a2+3); 367 l1.splice(next(l1.begin(), 2), l2); 368 assert(l1.size() == 6); 369 assert(distance(l1.begin(), l1.end()) == 6); 370 assert(l2.size() == 0); 371 assert(distance(l2.begin(), l2.end()) == 0); 372 std::list<int>::const_iterator i = l1.begin(); 373 assert(*i == 1); 374 ++i; 375 assert(*i == 2); 376 ++i; 377 assert(*i == 4); 378 ++i; 379 assert(*i == 5); 380 ++i; 381 assert(*i == 6); 382 ++i; 383 assert(*i == 3); 384 } 385 { 386 std::list<int> l1(a1, a1+3); 387 std::list<int> l2(a2, a2+3); 388 l1.splice(next(l1.begin(), 3), l2); 389 assert(l1.size() == 6); 390 assert(distance(l1.begin(), l1.end()) == 6); 391 assert(l2.size() == 0); 392 assert(distance(l2.begin(), l2.end()) == 0); 393 std::list<int>::const_iterator i = l1.begin(); 394 assert(*i == 1); 395 ++i; 396 assert(*i == 2); 397 ++i; 398 assert(*i == 3); 399 ++i; 400 assert(*i == 4); 401 ++i; 402 assert(*i == 5); 403 ++i; 404 assert(*i == 6); 405 } 406 #if _LIBCPP_DEBUG >= 1 407 { 408 std::list<int> v1(3); 409 std::list<int> v2(3); 410 v1.splice(v2.begin(), v2); 411 assert(false); 412 } 413 #endif 414 #if __cplusplus >= 201103L 415 { 416 std::list<int, min_allocator<int>> l1; 417 std::list<int, min_allocator<int>> l2; 418 l1.splice(l1.end(), l2); 419 assert(l1.size() == 0); 420 assert(distance(l1.begin(), l1.end()) == 0); 421 assert(l2.size() == 0); 422 assert(distance(l2.begin(), l2.end()) == 0); 423 } 424 { 425 std::list<int, min_allocator<int>> l1; 426 std::list<int, min_allocator<int>> l2(a2, a2+1); 427 l1.splice(l1.end(), l2); 428 assert(l1.size() == 1); 429 assert(distance(l1.begin(), l1.end()) == 1); 430 assert(l2.size() == 0); 431 assert(distance(l2.begin(), l2.end()) == 0); 432 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 433 assert(*i == 4); 434 } 435 { 436 std::list<int, min_allocator<int>> l1; 437 std::list<int, min_allocator<int>> l2(a2, a2+2); 438 l1.splice(l1.end(), l2); 439 assert(l1.size() == 2); 440 assert(distance(l1.begin(), l1.end()) == 2); 441 assert(l2.size() == 0); 442 assert(distance(l2.begin(), l2.end()) == 0); 443 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 444 assert(*i == 4); 445 ++i; 446 assert(*i == 5); 447 } 448 { 449 std::list<int, min_allocator<int>> l1; 450 std::list<int, min_allocator<int>> l2(a2, a2+3); 451 l1.splice(l1.end(), l2); 452 assert(l1.size() == 3); 453 assert(distance(l1.begin(), l1.end()) == 3); 454 assert(l2.size() == 0); 455 assert(distance(l2.begin(), l2.end()) == 0); 456 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 457 assert(*i == 4); 458 ++i; 459 assert(*i == 5); 460 ++i; 461 assert(*i == 6); 462 } 463 { 464 std::list<int, min_allocator<int>> l1(a1, a1+1); 465 std::list<int, min_allocator<int>> l2; 466 l1.splice(l1.begin(), l2); 467 assert(l1.size() == 1); 468 assert(distance(l1.begin(), l1.end()) == 1); 469 assert(l2.size() == 0); 470 assert(distance(l2.begin(), l2.end()) == 0); 471 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 472 assert(*i == 1); 473 } 474 { 475 std::list<int, min_allocator<int>> l1(a1, a1+1); 476 std::list<int, min_allocator<int>> l2; 477 l1.splice(l1.end(), l2); 478 assert(l1.size() == 1); 479 assert(distance(l1.begin(), l1.end()) == 1); 480 assert(l2.size() == 0); 481 assert(distance(l2.begin(), l2.end()) == 0); 482 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 483 assert(*i == 1); 484 } 485 { 486 std::list<int, min_allocator<int>> l1(a1, a1+1); 487 std::list<int, min_allocator<int>> l2(a2, a2+1); 488 l1.splice(l1.begin(), l2); 489 assert(l1.size() == 2); 490 assert(distance(l1.begin(), l1.end()) == 2); 491 assert(l2.size() == 0); 492 assert(distance(l2.begin(), l2.end()) == 0); 493 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 494 assert(*i == 4); 495 ++i; 496 assert(*i == 1); 497 } 498 { 499 std::list<int, min_allocator<int>> l1(a1, a1+1); 500 std::list<int, min_allocator<int>> l2(a2, a2+1); 501 l1.splice(l1.end(), l2); 502 assert(l1.size() == 2); 503 assert(distance(l1.begin(), l1.end()) == 2); 504 assert(l2.size() == 0); 505 assert(distance(l2.begin(), l2.end()) == 0); 506 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 507 assert(*i == 1); 508 ++i; 509 assert(*i == 4); 510 } 511 { 512 std::list<int, min_allocator<int>> l1(a1, a1+1); 513 std::list<int, min_allocator<int>> l2(a2, a2+2); 514 l1.splice(l1.begin(), l2); 515 assert(l1.size() == 3); 516 assert(distance(l1.begin(), l1.end()) == 3); 517 assert(l2.size() == 0); 518 assert(distance(l2.begin(), l2.end()) == 0); 519 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 520 assert(*i == 4); 521 ++i; 522 assert(*i == 5); 523 ++i; 524 assert(*i == 1); 525 } 526 { 527 std::list<int, min_allocator<int>> l1(a1, a1+1); 528 std::list<int, min_allocator<int>> l2(a2, a2+2); 529 l1.splice(l1.end(), l2); 530 assert(l1.size() == 3); 531 assert(distance(l1.begin(), l1.end()) == 3); 532 assert(l2.size() == 0); 533 assert(distance(l2.begin(), l2.end()) == 0); 534 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 535 assert(*i == 1); 536 ++i; 537 assert(*i == 4); 538 ++i; 539 assert(*i == 5); 540 } 541 { 542 std::list<int, min_allocator<int>> l1(a1, a1+1); 543 std::list<int, min_allocator<int>> l2(a2, a2+3); 544 l1.splice(l1.begin(), l2); 545 assert(l1.size() == 4); 546 assert(distance(l1.begin(), l1.end()) == 4); 547 assert(l2.size() == 0); 548 assert(distance(l2.begin(), l2.end()) == 0); 549 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 550 assert(*i == 4); 551 ++i; 552 assert(*i == 5); 553 ++i; 554 assert(*i == 6); 555 ++i; 556 assert(*i == 1); 557 } 558 { 559 std::list<int, min_allocator<int>> l1(a1, a1+1); 560 std::list<int, min_allocator<int>> l2(a2, a2+3); 561 l1.splice(l1.end(), l2); 562 assert(l1.size() == 4); 563 assert(distance(l1.begin(), l1.end()) == 4); 564 assert(l2.size() == 0); 565 assert(distance(l2.begin(), l2.end()) == 0); 566 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 567 assert(*i == 1); 568 ++i; 569 assert(*i == 4); 570 ++i; 571 assert(*i == 5); 572 ++i; 573 assert(*i == 6); 574 } 575 { 576 std::list<int, min_allocator<int>> l1(a1, a1+2); 577 std::list<int, min_allocator<int>> l2; 578 l1.splice(l1.begin(), l2); 579 assert(l1.size() == 2); 580 assert(distance(l1.begin(), l1.end()) == 2); 581 assert(l2.size() == 0); 582 assert(distance(l2.begin(), l2.end()) == 0); 583 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 584 assert(*i == 1); 585 ++i; 586 assert(*i == 2); 587 } 588 { 589 std::list<int, min_allocator<int>> l1(a1, a1+2); 590 std::list<int, min_allocator<int>> l2; 591 l1.splice(next(l1.begin()), l2); 592 assert(l1.size() == 2); 593 assert(distance(l1.begin(), l1.end()) == 2); 594 assert(l2.size() == 0); 595 assert(distance(l2.begin(), l2.end()) == 0); 596 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 597 assert(*i == 1); 598 ++i; 599 assert(*i == 2); 600 } 601 { 602 std::list<int, min_allocator<int>> l1(a1, a1+2); 603 std::list<int, min_allocator<int>> l2; 604 l1.splice(next(l1.begin(), 2), l2); 605 assert(l1.size() == 2); 606 assert(distance(l1.begin(), l1.end()) == 2); 607 assert(l2.size() == 0); 608 assert(distance(l2.begin(), l2.end()) == 0); 609 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 610 assert(*i == 1); 611 ++i; 612 assert(*i == 2); 613 } 614 { 615 std::list<int, min_allocator<int>> l1(a1, a1+2); 616 std::list<int, min_allocator<int>> l2(a2, a2+1); 617 l1.splice(l1.begin(), l2); 618 assert(l1.size() == 3); 619 assert(distance(l1.begin(), l1.end()) == 3); 620 assert(l2.size() == 0); 621 assert(distance(l2.begin(), l2.end()) == 0); 622 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 623 assert(*i == 4); 624 ++i; 625 assert(*i == 1); 626 ++i; 627 assert(*i == 2); 628 } 629 { 630 std::list<int, min_allocator<int>> l1(a1, a1+2); 631 std::list<int, min_allocator<int>> l2(a2, a2+1); 632 l1.splice(next(l1.begin()), l2); 633 assert(l1.size() == 3); 634 assert(distance(l1.begin(), l1.end()) == 3); 635 assert(l2.size() == 0); 636 assert(distance(l2.begin(), l2.end()) == 0); 637 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 638 assert(*i == 1); 639 ++i; 640 assert(*i == 4); 641 ++i; 642 assert(*i == 2); 643 } 644 { 645 std::list<int, min_allocator<int>> l1(a1, a1+2); 646 std::list<int, min_allocator<int>> l2(a2, a2+1); 647 l1.splice(next(l1.begin(), 2), l2); 648 assert(l1.size() == 3); 649 assert(distance(l1.begin(), l1.end()) == 3); 650 assert(l2.size() == 0); 651 assert(distance(l2.begin(), l2.end()) == 0); 652 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 653 assert(*i == 1); 654 ++i; 655 assert(*i == 2); 656 ++i; 657 assert(*i == 4); 658 } 659 { 660 std::list<int, min_allocator<int>> l1(a1, a1+2); 661 std::list<int, min_allocator<int>> l2(a2, a2+2); 662 l1.splice(l1.begin(), l2); 663 assert(l1.size() == 4); 664 assert(distance(l1.begin(), l1.end()) == 4); 665 assert(l2.size() == 0); 666 assert(distance(l2.begin(), l2.end()) == 0); 667 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 668 assert(*i == 4); 669 ++i; 670 assert(*i == 5); 671 ++i; 672 assert(*i == 1); 673 ++i; 674 assert(*i == 2); 675 } 676 { 677 std::list<int, min_allocator<int>> l1(a1, a1+2); 678 std::list<int, min_allocator<int>> l2(a2, a2+2); 679 l1.splice(next(l1.begin()), l2); 680 assert(l1.size() == 4); 681 assert(distance(l1.begin(), l1.end()) == 4); 682 assert(l2.size() == 0); 683 assert(distance(l2.begin(), l2.end()) == 0); 684 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 685 assert(*i == 1); 686 ++i; 687 assert(*i == 4); 688 ++i; 689 assert(*i == 5); 690 ++i; 691 assert(*i == 2); 692 } 693 { 694 std::list<int, min_allocator<int>> l1(a1, a1+2); 695 std::list<int, min_allocator<int>> l2(a2, a2+2); 696 l1.splice(next(l1.begin(), 2), l2); 697 assert(l1.size() == 4); 698 assert(distance(l1.begin(), l1.end()) == 4); 699 assert(l2.size() == 0); 700 assert(distance(l2.begin(), l2.end()) == 0); 701 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 702 assert(*i == 1); 703 ++i; 704 assert(*i == 2); 705 ++i; 706 assert(*i == 4); 707 ++i; 708 assert(*i == 5); 709 } 710 { 711 std::list<int, min_allocator<int>> l1(a1, a1+3); 712 std::list<int, min_allocator<int>> l2(a2, a2+3); 713 l1.splice(l1.begin(), l2); 714 assert(l1.size() == 6); 715 assert(distance(l1.begin(), l1.end()) == 6); 716 assert(l2.size() == 0); 717 assert(distance(l2.begin(), l2.end()) == 0); 718 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 719 assert(*i == 4); 720 ++i; 721 assert(*i == 5); 722 ++i; 723 assert(*i == 6); 724 ++i; 725 assert(*i == 1); 726 ++i; 727 assert(*i == 2); 728 ++i; 729 assert(*i == 3); 730 } 731 { 732 std::list<int, min_allocator<int>> l1(a1, a1+3); 733 std::list<int, min_allocator<int>> l2(a2, a2+3); 734 l1.splice(next(l1.begin()), l2); 735 assert(l1.size() == 6); 736 assert(distance(l1.begin(), l1.end()) == 6); 737 assert(l2.size() == 0); 738 assert(distance(l2.begin(), l2.end()) == 0); 739 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 740 assert(*i == 1); 741 ++i; 742 assert(*i == 4); 743 ++i; 744 assert(*i == 5); 745 ++i; 746 assert(*i == 6); 747 ++i; 748 assert(*i == 2); 749 ++i; 750 assert(*i == 3); 751 } 752 { 753 std::list<int, min_allocator<int>> l1(a1, a1+3); 754 std::list<int, min_allocator<int>> l2(a2, a2+3); 755 l1.splice(next(l1.begin(), 2), l2); 756 assert(l1.size() == 6); 757 assert(distance(l1.begin(), l1.end()) == 6); 758 assert(l2.size() == 0); 759 assert(distance(l2.begin(), l2.end()) == 0); 760 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 761 assert(*i == 1); 762 ++i; 763 assert(*i == 2); 764 ++i; 765 assert(*i == 4); 766 ++i; 767 assert(*i == 5); 768 ++i; 769 assert(*i == 6); 770 ++i; 771 assert(*i == 3); 772 } 773 { 774 std::list<int, min_allocator<int>> l1(a1, a1+3); 775 std::list<int, min_allocator<int>> l2(a2, a2+3); 776 l1.splice(next(l1.begin(), 3), l2); 777 assert(l1.size() == 6); 778 assert(distance(l1.begin(), l1.end()) == 6); 779 assert(l2.size() == 0); 780 assert(distance(l2.begin(), l2.end()) == 0); 781 std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 782 assert(*i == 1); 783 ++i; 784 assert(*i == 2); 785 ++i; 786 assert(*i == 3); 787 ++i; 788 assert(*i == 4); 789 ++i; 790 assert(*i == 5); 791 ++i; 792 assert(*i == 6); 793 } 794 #if _LIBCPP_DEBUG >= 1 795 { 796 std::list<int, min_allocator<int>> v1(3); 797 std::list<int, min_allocator<int>> v2(3); 798 v1.splice(v2.begin(), v2); 799 assert(false); 800 } 801 #endif 802 #endif 803 } 804
