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