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