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
20int 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