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 int main()
     18 {
     19     int a1[] = {1, 2, 3};
     20     int a2[] = {4, 5, 6};
     21     {
     22         std::list<int> l1;
     23         std::list<int> l2;
     24         l1.splice(l1.end(), l2);
     25         assert(l1.size() == 0);
     26         assert(distance(l1.begin(), l1.end()) == 0);
     27         assert(l2.size() == 0);
     28         assert(distance(l2.begin(), l2.end()) == 0);
     29     }
     30     {
     31         std::list<int> l1;
     32         std::list<int> l2(a2, a2+1);
     33         l1.splice(l1.end(), l2);
     34         assert(l1.size() == 1);
     35         assert(distance(l1.begin(), l1.end()) == 1);
     36         assert(l2.size() == 0);
     37         assert(distance(l2.begin(), l2.end()) == 0);
     38         std::list<int>::const_iterator i = l1.begin();
     39         assert(*i == 4);
     40     }
     41     {
     42         std::list<int> l1;
     43         std::list<int> l2(a2, a2+2);
     44         l1.splice(l1.end(), l2);
     45         assert(l1.size() == 2);
     46         assert(distance(l1.begin(), l1.end()) == 2);
     47         assert(l2.size() == 0);
     48         assert(distance(l2.begin(), l2.end()) == 0);
     49         std::list<int>::const_iterator i = l1.begin();
     50         assert(*i == 4);
     51         ++i;
     52         assert(*i == 5);
     53     }
     54     {
     55         std::list<int> l1;
     56         std::list<int> l2(a2, a2+3);
     57         l1.splice(l1.end(), l2);
     58         assert(l1.size() == 3);
     59         assert(distance(l1.begin(), l1.end()) == 3);
     60         assert(l2.size() == 0);
     61         assert(distance(l2.begin(), l2.end()) == 0);
     62         std::list<int>::const_iterator i = l1.begin();
     63         assert(*i == 4);
     64         ++i;
     65         assert(*i == 5);
     66         ++i;
     67         assert(*i == 6);
     68     }
     69     {
     70         std::list<int> l1(a1, a1+1);
     71         std::list<int> l2;
     72         l1.splice(l1.begin(), l2);
     73         assert(l1.size() == 1);
     74         assert(distance(l1.begin(), l1.end()) == 1);
     75         assert(l2.size() == 0);
     76         assert(distance(l2.begin(), l2.end()) == 0);
     77         std::list<int>::const_iterator i = l1.begin();
     78         assert(*i == 1);
     79     }
     80     {
     81         std::list<int> l1(a1, a1+1);
     82         std::list<int> l2;
     83         l1.splice(l1.end(), l2);
     84         assert(l1.size() == 1);
     85         assert(distance(l1.begin(), l1.end()) == 1);
     86         assert(l2.size() == 0);
     87         assert(distance(l2.begin(), l2.end()) == 0);
     88         std::list<int>::const_iterator i = l1.begin();
     89         assert(*i == 1);
     90     }
     91     {
     92         std::list<int> l1(a1, a1+1);
     93         std::list<int> l2(a2, a2+1);
     94         l1.splice(l1.begin(), l2);
     95         assert(l1.size() == 2);
     96         assert(distance(l1.begin(), l1.end()) == 2);
     97         assert(l2.size() == 0);
     98         assert(distance(l2.begin(), l2.end()) == 0);
     99         std::list<int>::const_iterator i = l1.begin();
    100         assert(*i == 4);
    101         ++i;
    102         assert(*i == 1);
    103     }
    104     {
    105         std::list<int> l1(a1, a1+1);
    106         std::list<int> l2(a2, a2+1);
    107         l1.splice(l1.end(), l2);
    108         assert(l1.size() == 2);
    109         assert(distance(l1.begin(), l1.end()) == 2);
    110         assert(l2.size() == 0);
    111         assert(distance(l2.begin(), l2.end()) == 0);
    112         std::list<int>::const_iterator i = l1.begin();
    113         assert(*i == 1);
    114         ++i;
    115         assert(*i == 4);
    116     }
    117     {
    118         std::list<int> l1(a1, a1+1);
    119         std::list<int> l2(a2, a2+2);
    120         l1.splice(l1.begin(), l2);
    121         assert(l1.size() == 3);
    122         assert(distance(l1.begin(), l1.end()) == 3);
    123         assert(l2.size() == 0);
    124         assert(distance(l2.begin(), l2.end()) == 0);
    125         std::list<int>::const_iterator i = l1.begin();
    126         assert(*i == 4);
    127         ++i;
    128         assert(*i == 5);
    129         ++i;
    130         assert(*i == 1);
    131     }
    132     {
    133         std::list<int> l1(a1, a1+1);
    134         std::list<int> l2(a2, a2+2);
    135         l1.splice(l1.end(), l2);
    136         assert(l1.size() == 3);
    137         assert(distance(l1.begin(), l1.end()) == 3);
    138         assert(l2.size() == 0);
    139         assert(distance(l2.begin(), l2.end()) == 0);
    140         std::list<int>::const_iterator i = l1.begin();
    141         assert(*i == 1);
    142         ++i;
    143         assert(*i == 4);
    144         ++i;
    145         assert(*i == 5);
    146     }
    147     {
    148         std::list<int> l1(a1, a1+1);
    149         std::list<int> l2(a2, a2+3);
    150         l1.splice(l1.begin(), l2);
    151         assert(l1.size() == 4);
    152         assert(distance(l1.begin(), l1.end()) == 4);
    153         assert(l2.size() == 0);
    154         assert(distance(l2.begin(), l2.end()) == 0);
    155         std::list<int>::const_iterator i = l1.begin();
    156         assert(*i == 4);
    157         ++i;
    158         assert(*i == 5);
    159         ++i;
    160         assert(*i == 6);
    161         ++i;
    162         assert(*i == 1);
    163     }
    164     {
    165         std::list<int> l1(a1, a1+1);
    166         std::list<int> l2(a2, a2+3);
    167         l1.splice(l1.end(), l2);
    168         assert(l1.size() == 4);
    169         assert(distance(l1.begin(), l1.end()) == 4);
    170         assert(l2.size() == 0);
    171         assert(distance(l2.begin(), l2.end()) == 0);
    172         std::list<int>::const_iterator i = l1.begin();
    173         assert(*i == 1);
    174         ++i;
    175         assert(*i == 4);
    176         ++i;
    177         assert(*i == 5);
    178         ++i;
    179         assert(*i == 6);
    180     }
    181     {
    182         std::list<int> l1(a1, a1+2);
    183         std::list<int> l2;
    184         l1.splice(l1.begin(), l2);
    185         assert(l1.size() == 2);
    186         assert(distance(l1.begin(), l1.end()) == 2);
    187         assert(l2.size() == 0);
    188         assert(distance(l2.begin(), l2.end()) == 0);
    189         std::list<int>::const_iterator i = l1.begin();
    190         assert(*i == 1);
    191         ++i;
    192         assert(*i == 2);
    193     }
    194     {
    195         std::list<int> l1(a1, a1+2);
    196         std::list<int> l2;
    197         l1.splice(next(l1.begin()), l2);
    198         assert(l1.size() == 2);
    199         assert(distance(l1.begin(), l1.end()) == 2);
    200         assert(l2.size() == 0);
    201         assert(distance(l2.begin(), l2.end()) == 0);
    202         std::list<int>::const_iterator i = l1.begin();
    203         assert(*i == 1);
    204         ++i;
    205         assert(*i == 2);
    206     }
    207     {
    208         std::list<int> l1(a1, a1+2);
    209         std::list<int> l2;
    210         l1.splice(next(l1.begin(), 2), l2);
    211         assert(l1.size() == 2);
    212         assert(distance(l1.begin(), l1.end()) == 2);
    213         assert(l2.size() == 0);
    214         assert(distance(l2.begin(), l2.end()) == 0);
    215         std::list<int>::const_iterator i = l1.begin();
    216         assert(*i == 1);
    217         ++i;
    218         assert(*i == 2);
    219     }
    220     {
    221         std::list<int> l1(a1, a1+2);
    222         std::list<int> l2(a2, a2+1);
    223         l1.splice(l1.begin(), l2);
    224         assert(l1.size() == 3);
    225         assert(distance(l1.begin(), l1.end()) == 3);
    226         assert(l2.size() == 0);
    227         assert(distance(l2.begin(), l2.end()) == 0);
    228         std::list<int>::const_iterator i = l1.begin();
    229         assert(*i == 4);
    230         ++i;
    231         assert(*i == 1);
    232         ++i;
    233         assert(*i == 2);
    234     }
    235     {
    236         std::list<int> l1(a1, a1+2);
    237         std::list<int> l2(a2, a2+1);
    238         l1.splice(next(l1.begin()), l2);
    239         assert(l1.size() == 3);
    240         assert(distance(l1.begin(), l1.end()) == 3);
    241         assert(l2.size() == 0);
    242         assert(distance(l2.begin(), l2.end()) == 0);
    243         std::list<int>::const_iterator i = l1.begin();
    244         assert(*i == 1);
    245         ++i;
    246         assert(*i == 4);
    247         ++i;
    248         assert(*i == 2);
    249     }
    250     {
    251         std::list<int> l1(a1, a1+2);
    252         std::list<int> l2(a2, a2+1);
    253         l1.splice(next(l1.begin(), 2), l2);
    254         assert(l1.size() == 3);
    255         assert(distance(l1.begin(), l1.end()) == 3);
    256         assert(l2.size() == 0);
    257         assert(distance(l2.begin(), l2.end()) == 0);
    258         std::list<int>::const_iterator i = l1.begin();
    259         assert(*i == 1);
    260         ++i;
    261         assert(*i == 2);
    262         ++i;
    263         assert(*i == 4);
    264     }
    265     {
    266         std::list<int> l1(a1, a1+2);
    267         std::list<int> l2(a2, a2+2);
    268         l1.splice(l1.begin(), l2);
    269         assert(l1.size() == 4);
    270         assert(distance(l1.begin(), l1.end()) == 4);
    271         assert(l2.size() == 0);
    272         assert(distance(l2.begin(), l2.end()) == 0);
    273         std::list<int>::const_iterator i = l1.begin();
    274         assert(*i == 4);
    275         ++i;
    276         assert(*i == 5);
    277         ++i;
    278         assert(*i == 1);
    279         ++i;
    280         assert(*i == 2);
    281     }
    282     {
    283         std::list<int> l1(a1, a1+2);
    284         std::list<int> l2(a2, a2+2);
    285         l1.splice(next(l1.begin()), l2);
    286         assert(l1.size() == 4);
    287         assert(distance(l1.begin(), l1.end()) == 4);
    288         assert(l2.size() == 0);
    289         assert(distance(l2.begin(), l2.end()) == 0);
    290         std::list<int>::const_iterator i = l1.begin();
    291         assert(*i == 1);
    292         ++i;
    293         assert(*i == 4);
    294         ++i;
    295         assert(*i == 5);
    296         ++i;
    297         assert(*i == 2);
    298     }
    299     {
    300         std::list<int> l1(a1, a1+2);
    301         std::list<int> l2(a2, a2+2);
    302         l1.splice(next(l1.begin(), 2), l2);
    303         assert(l1.size() == 4);
    304         assert(distance(l1.begin(), l1.end()) == 4);
    305         assert(l2.size() == 0);
    306         assert(distance(l2.begin(), l2.end()) == 0);
    307         std::list<int>::const_iterator i = l1.begin();
    308         assert(*i == 1);
    309         ++i;
    310         assert(*i == 2);
    311         ++i;
    312         assert(*i == 4);
    313         ++i;
    314         assert(*i == 5);
    315     }
    316     {
    317         std::list<int> l1(a1, a1+3);
    318         std::list<int> l2(a2, a2+3);
    319         l1.splice(l1.begin(), l2);
    320         assert(l1.size() == 6);
    321         assert(distance(l1.begin(), l1.end()) == 6);
    322         assert(l2.size() == 0);
    323         assert(distance(l2.begin(), l2.end()) == 0);
    324         std::list<int>::const_iterator i = l1.begin();
    325         assert(*i == 4);
    326         ++i;
    327         assert(*i == 5);
    328         ++i;
    329         assert(*i == 6);
    330         ++i;
    331         assert(*i == 1);
    332         ++i;
    333         assert(*i == 2);
    334         ++i;
    335         assert(*i == 3);
    336     }
    337     {
    338         std::list<int> l1(a1, a1+3);
    339         std::list<int> l2(a2, a2+3);
    340         l1.splice(next(l1.begin()), l2);
    341         assert(l1.size() == 6);
    342         assert(distance(l1.begin(), l1.end()) == 6);
    343         assert(l2.size() == 0);
    344         assert(distance(l2.begin(), l2.end()) == 0);
    345         std::list<int>::const_iterator i = l1.begin();
    346         assert(*i == 1);
    347         ++i;
    348         assert(*i == 4);
    349         ++i;
    350         assert(*i == 5);
    351         ++i;
    352         assert(*i == 6);
    353         ++i;
    354         assert(*i == 2);
    355         ++i;
    356         assert(*i == 3);
    357     }
    358     {
    359         std::list<int> l1(a1, a1+3);
    360         std::list<int> l2(a2, a2+3);
    361         l1.splice(next(l1.begin(), 2), l2);
    362         assert(l1.size() == 6);
    363         assert(distance(l1.begin(), l1.end()) == 6);
    364         assert(l2.size() == 0);
    365         assert(distance(l2.begin(), l2.end()) == 0);
    366         std::list<int>::const_iterator i = l1.begin();
    367         assert(*i == 1);
    368         ++i;
    369         assert(*i == 2);
    370         ++i;
    371         assert(*i == 4);
    372         ++i;
    373         assert(*i == 5);
    374         ++i;
    375         assert(*i == 6);
    376         ++i;
    377         assert(*i == 3);
    378     }
    379     {
    380         std::list<int> l1(a1, a1+3);
    381         std::list<int> l2(a2, a2+3);
    382         l1.splice(next(l1.begin(), 3), l2);
    383         assert(l1.size() == 6);
    384         assert(distance(l1.begin(), l1.end()) == 6);
    385         assert(l2.size() == 0);
    386         assert(distance(l2.begin(), l2.end()) == 0);
    387         std::list<int>::const_iterator i = l1.begin();
    388         assert(*i == 1);
    389         ++i;
    390         assert(*i == 2);
    391         ++i;
    392         assert(*i == 3);
    393         ++i;
    394         assert(*i == 4);
    395         ++i;
    396         assert(*i == 5);
    397         ++i;
    398         assert(*i == 6);
    399     }
    400 }
    401