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
main()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