splice_pos_list.pass.cpp revision b64f8b07c104c6cc986570ac8ee0ed16a9f23976 
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
17int 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