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