1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <list>
10
11// void splice(const_iterator position, list& x);
12
13#include <list>
14#include <cassert>
15
16#include "test_macros.h"
17#include "min_allocator.h"
18
19int main(int, char**) {
20 int a1[] = {1, 2, 3};
21 int a2[] = {4, 5, 6};
22 {
23 std::list<int> l1;
24 std::list<int> l2;
25 l1.splice(position: l1.end(), x&: l2);
26 assert(l1.size() == 0);
27 assert(std::distance(l1.begin(), l1.end()) == 0);
28 assert(l2.size() == 0);
29 assert(std::distance(l2.begin(), l2.end()) == 0);
30 }
31 {
32 std::list<int> l1;
33 std::list<int> l2(a2, a2 + 1);
34 l1.splice(position: l1.end(), x&: l2);
35 assert(l1.size() == 1);
36 assert(std::distance(l1.begin(), l1.end()) == 1);
37 assert(l2.size() == 0);
38 assert(std::distance(l2.begin(), l2.end()) == 0);
39 std::list<int>::const_iterator i = l1.begin();
40 assert(*i == 4);
41 }
42 {
43 std::list<int> l1;
44 std::list<int> l2(a2, a2 + 2);
45 l1.splice(position: l1.end(), x&: l2);
46 assert(l1.size() == 2);
47 assert(std::distance(l1.begin(), l1.end()) == 2);
48 assert(l2.size() == 0);
49 assert(std::distance(l2.begin(), l2.end()) == 0);
50 std::list<int>::const_iterator i = l1.begin();
51 assert(*i == 4);
52 ++i;
53 assert(*i == 5);
54 }
55 {
56 std::list<int> l1;
57 std::list<int> l2(a2, a2 + 3);
58 l1.splice(position: l1.end(), x&: l2);
59 assert(l1.size() == 3);
60 assert(std::distance(l1.begin(), l1.end()) == 3);
61 assert(l2.size() == 0);
62 assert(std::distance(l2.begin(), l2.end()) == 0);
63 std::list<int>::const_iterator i = l1.begin();
64 assert(*i == 4);
65 ++i;
66 assert(*i == 5);
67 ++i;
68 assert(*i == 6);
69 }
70 {
71 std::list<int> l1(a1, a1 + 1);
72 std::list<int> l2;
73 l1.splice(position: l1.begin(), x&: l2);
74 assert(l1.size() == 1);
75 assert(std::distance(l1.begin(), l1.end()) == 1);
76 assert(l2.size() == 0);
77 assert(std::distance(l2.begin(), l2.end()) == 0);
78 std::list<int>::const_iterator i = l1.begin();
79 assert(*i == 1);
80 }
81 {
82 std::list<int> l1(a1, a1 + 1);
83 std::list<int> l2;
84 l1.splice(position: l1.end(), x&: l2);
85 assert(l1.size() == 1);
86 assert(std::distance(l1.begin(), l1.end()) == 1);
87 assert(l2.size() == 0);
88 assert(std::distance(l2.begin(), l2.end()) == 0);
89 std::list<int>::const_iterator i = l1.begin();
90 assert(*i == 1);
91 }
92 {
93 std::list<int> l1(a1, a1 + 1);
94 std::list<int> l2(a2, a2 + 1);
95 l1.splice(position: l1.begin(), x&: l2);
96 assert(l1.size() == 2);
97 assert(std::distance(l1.begin(), l1.end()) == 2);
98 assert(l2.size() == 0);
99 assert(std::distance(l2.begin(), l2.end()) == 0);
100 std::list<int>::const_iterator i = l1.begin();
101 assert(*i == 4);
102 ++i;
103 assert(*i == 1);
104 }
105 {
106 std::list<int> l1(a1, a1 + 1);
107 std::list<int> l2(a2, a2 + 1);
108 l1.splice(position: l1.end(), x&: l2);
109 assert(l1.size() == 2);
110 assert(std::distance(l1.begin(), l1.end()) == 2);
111 assert(l2.size() == 0);
112 assert(std::distance(l2.begin(), l2.end()) == 0);
113 std::list<int>::const_iterator i = l1.begin();
114 assert(*i == 1);
115 ++i;
116 assert(*i == 4);
117 }
118 {
119 std::list<int> l1(a1, a1 + 1);
120 std::list<int> l2(a2, a2 + 2);
121 l1.splice(position: l1.begin(), x&: l2);
122 assert(l1.size() == 3);
123 assert(std::distance(l1.begin(), l1.end()) == 3);
124 assert(l2.size() == 0);
125 assert(std::distance(l2.begin(), l2.end()) == 0);
126 std::list<int>::const_iterator i = l1.begin();
127 assert(*i == 4);
128 ++i;
129 assert(*i == 5);
130 ++i;
131 assert(*i == 1);
132 }
133 {
134 std::list<int> l1(a1, a1 + 1);
135 std::list<int> l2(a2, a2 + 2);
136 l1.splice(position: l1.end(), x&: l2);
137 assert(l1.size() == 3);
138 assert(std::distance(l1.begin(), l1.end()) == 3);
139 assert(l2.size() == 0);
140 assert(std::distance(l2.begin(), l2.end()) == 0);
141 std::list<int>::const_iterator i = l1.begin();
142 assert(*i == 1);
143 ++i;
144 assert(*i == 4);
145 ++i;
146 assert(*i == 5);
147 }
148 {
149 std::list<int> l1(a1, a1 + 1);
150 std::list<int> l2(a2, a2 + 3);
151 l1.splice(position: l1.begin(), x&: l2);
152 assert(l1.size() == 4);
153 assert(std::distance(l1.begin(), l1.end()) == 4);
154 assert(l2.size() == 0);
155 assert(std::distance(l2.begin(), l2.end()) == 0);
156 std::list<int>::const_iterator i = l1.begin();
157 assert(*i == 4);
158 ++i;
159 assert(*i == 5);
160 ++i;
161 assert(*i == 6);
162 ++i;
163 assert(*i == 1);
164 }
165 {
166 std::list<int> l1(a1, a1 + 1);
167 std::list<int> l2(a2, a2 + 3);
168 l1.splice(position: l1.end(), x&: l2);
169 assert(l1.size() == 4);
170 assert(std::distance(l1.begin(), l1.end()) == 4);
171 assert(l2.size() == 0);
172 assert(std::distance(l2.begin(), l2.end()) == 0);
173 std::list<int>::const_iterator i = l1.begin();
174 assert(*i == 1);
175 ++i;
176 assert(*i == 4);
177 ++i;
178 assert(*i == 5);
179 ++i;
180 assert(*i == 6);
181 }
182 {
183 std::list<int> l1(a1, a1 + 2);
184 std::list<int> l2;
185 l1.splice(position: l1.begin(), x&: l2);
186 assert(l1.size() == 2);
187 assert(std::distance(l1.begin(), l1.end()) == 2);
188 assert(l2.size() == 0);
189 assert(std::distance(l2.begin(), l2.end()) == 0);
190 std::list<int>::const_iterator i = l1.begin();
191 assert(*i == 1);
192 ++i;
193 assert(*i == 2);
194 }
195 {
196 std::list<int> l1(a1, a1 + 2);
197 std::list<int> l2;
198 l1.splice(position: std::next(x: l1.begin()), x&: l2);
199 assert(l1.size() == 2);
200 assert(std::distance(l1.begin(), l1.end()) == 2);
201 assert(l2.size() == 0);
202 assert(std::distance(l2.begin(), l2.end()) == 0);
203 std::list<int>::const_iterator i = l1.begin();
204 assert(*i == 1);
205 ++i;
206 assert(*i == 2);
207 }
208 {
209 std::list<int> l1(a1, a1 + 2);
210 std::list<int> l2;
211 l1.splice(position: std::next(x: l1.begin(), n: 2), x&: l2);
212 assert(l1.size() == 2);
213 assert(std::distance(l1.begin(), l1.end()) == 2);
214 assert(l2.size() == 0);
215 assert(std::distance(l2.begin(), l2.end()) == 0);
216 std::list<int>::const_iterator i = l1.begin();
217 assert(*i == 1);
218 ++i;
219 assert(*i == 2);
220 }
221 {
222 std::list<int> l1(a1, a1 + 2);
223 std::list<int> l2(a2, a2 + 1);
224 l1.splice(position: l1.begin(), x&: l2);
225 assert(l1.size() == 3);
226 assert(std::distance(l1.begin(), l1.end()) == 3);
227 assert(l2.size() == 0);
228 assert(std::distance(l2.begin(), l2.end()) == 0);
229 std::list<int>::const_iterator i = l1.begin();
230 assert(*i == 4);
231 ++i;
232 assert(*i == 1);
233 ++i;
234 assert(*i == 2);
235 }
236 {
237 std::list<int> l1(a1, a1 + 2);
238 std::list<int> l2(a2, a2 + 1);
239 l1.splice(position: std::next(x: l1.begin()), x&: l2);
240 assert(l1.size() == 3);
241 assert(std::distance(l1.begin(), l1.end()) == 3);
242 assert(l2.size() == 0);
243 assert(std::distance(l2.begin(), l2.end()) == 0);
244 std::list<int>::const_iterator i = l1.begin();
245 assert(*i == 1);
246 ++i;
247 assert(*i == 4);
248 ++i;
249 assert(*i == 2);
250 }
251 {
252 std::list<int> l1(a1, a1 + 2);
253 std::list<int> l2(a2, a2 + 1);
254 l1.splice(position: std::next(x: l1.begin(), n: 2), x&: l2);
255 assert(l1.size() == 3);
256 assert(std::distance(l1.begin(), l1.end()) == 3);
257 assert(l2.size() == 0);
258 assert(std::distance(l2.begin(), l2.end()) == 0);
259 std::list<int>::const_iterator i = l1.begin();
260 assert(*i == 1);
261 ++i;
262 assert(*i == 2);
263 ++i;
264 assert(*i == 4);
265 }
266 {
267 std::list<int> l1(a1, a1 + 2);
268 std::list<int> l2(a2, a2 + 2);
269 l1.splice(position: l1.begin(), x&: l2);
270 assert(l1.size() == 4);
271 assert(std::distance(l1.begin(), l1.end()) == 4);
272 assert(l2.size() == 0);
273 assert(std::distance(l2.begin(), l2.end()) == 0);
274 std::list<int>::const_iterator i = l1.begin();
275 assert(*i == 4);
276 ++i;
277 assert(*i == 5);
278 ++i;
279 assert(*i == 1);
280 ++i;
281 assert(*i == 2);
282 }
283 {
284 std::list<int> l1(a1, a1 + 2);
285 std::list<int> l2(a2, a2 + 2);
286 l1.splice(position: std::next(x: l1.begin()), x&: l2);
287 assert(l1.size() == 4);
288 assert(std::distance(l1.begin(), l1.end()) == 4);
289 assert(l2.size() == 0);
290 assert(std::distance(l2.begin(), l2.end()) == 0);
291 std::list<int>::const_iterator i = l1.begin();
292 assert(*i == 1);
293 ++i;
294 assert(*i == 4);
295 ++i;
296 assert(*i == 5);
297 ++i;
298 assert(*i == 2);
299 }
300 {
301 std::list<int> l1(a1, a1 + 2);
302 std::list<int> l2(a2, a2 + 2);
303 l1.splice(position: std::next(x: l1.begin(), n: 2), x&: l2);
304 assert(l1.size() == 4);
305 assert(std::distance(l1.begin(), l1.end()) == 4);
306 assert(l2.size() == 0);
307 assert(std::distance(l2.begin(), l2.end()) == 0);
308 std::list<int>::const_iterator i = l1.begin();
309 assert(*i == 1);
310 ++i;
311 assert(*i == 2);
312 ++i;
313 assert(*i == 4);
314 ++i;
315 assert(*i == 5);
316 }
317 {
318 std::list<int> l1(a1, a1 + 3);
319 std::list<int> l2(a2, a2 + 3);
320 l1.splice(position: l1.begin(), x&: l2);
321 assert(l1.size() == 6);
322 assert(std::distance(l1.begin(), l1.end()) == 6);
323 assert(l2.size() == 0);
324 assert(std::distance(l2.begin(), l2.end()) == 0);
325 std::list<int>::const_iterator i = l1.begin();
326 assert(*i == 4);
327 ++i;
328 assert(*i == 5);
329 ++i;
330 assert(*i == 6);
331 ++i;
332 assert(*i == 1);
333 ++i;
334 assert(*i == 2);
335 ++i;
336 assert(*i == 3);
337 }
338 {
339 std::list<int> l1(a1, a1 + 3);
340 std::list<int> l2(a2, a2 + 3);
341 l1.splice(position: std::next(x: l1.begin()), x&: l2);
342 assert(l1.size() == 6);
343 assert(std::distance(l1.begin(), l1.end()) == 6);
344 assert(l2.size() == 0);
345 assert(std::distance(l2.begin(), l2.end()) == 0);
346 std::list<int>::const_iterator i = l1.begin();
347 assert(*i == 1);
348 ++i;
349 assert(*i == 4);
350 ++i;
351 assert(*i == 5);
352 ++i;
353 assert(*i == 6);
354 ++i;
355 assert(*i == 2);
356 ++i;
357 assert(*i == 3);
358 }
359 {
360 std::list<int> l1(a1, a1 + 3);
361 std::list<int> l2(a2, a2 + 3);
362 l1.splice(position: std::next(x: l1.begin(), n: 2), x&: l2);
363 assert(l1.size() == 6);
364 assert(std::distance(l1.begin(), l1.end()) == 6);
365 assert(l2.size() == 0);
366 assert(std::distance(l2.begin(), l2.end()) == 0);
367 std::list<int>::const_iterator i = l1.begin();
368 assert(*i == 1);
369 ++i;
370 assert(*i == 2);
371 ++i;
372 assert(*i == 4);
373 ++i;
374 assert(*i == 5);
375 ++i;
376 assert(*i == 6);
377 ++i;
378 assert(*i == 3);
379 }
380 {
381 std::list<int> l1(a1, a1 + 3);
382 std::list<int> l2(a2, a2 + 3);
383 l1.splice(position: std::next(x: l1.begin(), n: 3), x&: l2);
384 assert(l1.size() == 6);
385 assert(std::distance(l1.begin(), l1.end()) == 6);
386 assert(l2.size() == 0);
387 assert(std::distance(l2.begin(), l2.end()) == 0);
388 std::list<int>::const_iterator i = l1.begin();
389 assert(*i == 1);
390 ++i;
391 assert(*i == 2);
392 ++i;
393 assert(*i == 3);
394 ++i;
395 assert(*i == 4);
396 ++i;
397 assert(*i == 5);
398 ++i;
399 assert(*i == 6);
400 }
401#if TEST_STD_VER >= 11
402 {
403 std::list<int, min_allocator<int>> l1;
404 std::list<int, min_allocator<int>> l2;
405 l1.splice(l1.end(), l2);
406 assert(l1.size() == 0);
407 assert(std::distance(l1.begin(), l1.end()) == 0);
408 assert(l2.size() == 0);
409 assert(std::distance(l2.begin(), l2.end()) == 0);
410 }
411 {
412 std::list<int, min_allocator<int>> l1;
413 std::list<int, min_allocator<int>> l2(a2, a2 + 1);
414 l1.splice(l1.end(), l2);
415 assert(l1.size() == 1);
416 assert(std::distance(l1.begin(), l1.end()) == 1);
417 assert(l2.size() == 0);
418 assert(std::distance(l2.begin(), l2.end()) == 0);
419 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
420 assert(*i == 4);
421 }
422 {
423 std::list<int, min_allocator<int>> l1;
424 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
425 l1.splice(l1.end(), l2);
426 assert(l1.size() == 2);
427 assert(std::distance(l1.begin(), l1.end()) == 2);
428 assert(l2.size() == 0);
429 assert(std::distance(l2.begin(), l2.end()) == 0);
430 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
431 assert(*i == 4);
432 ++i;
433 assert(*i == 5);
434 }
435 {
436 std::list<int, min_allocator<int>> l1;
437 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
438 l1.splice(l1.end(), l2);
439 assert(l1.size() == 3);
440 assert(std::distance(l1.begin(), l1.end()) == 3);
441 assert(l2.size() == 0);
442 assert(std::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 ++i;
448 assert(*i == 6);
449 }
450 {
451 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
452 std::list<int, min_allocator<int>> l2;
453 l1.splice(l1.begin(), l2);
454 assert(l1.size() == 1);
455 assert(std::distance(l1.begin(), l1.end()) == 1);
456 assert(l2.size() == 0);
457 assert(std::distance(l2.begin(), l2.end()) == 0);
458 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
459 assert(*i == 1);
460 }
461 {
462 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
463 std::list<int, min_allocator<int>> l2;
464 l1.splice(l1.end(), l2);
465 assert(l1.size() == 1);
466 assert(std::distance(l1.begin(), l1.end()) == 1);
467 assert(l2.size() == 0);
468 assert(std::distance(l2.begin(), l2.end()) == 0);
469 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
470 assert(*i == 1);
471 }
472 {
473 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
474 std::list<int, min_allocator<int>> l2(a2, a2 + 1);
475 l1.splice(l1.begin(), l2);
476 assert(l1.size() == 2);
477 assert(std::distance(l1.begin(), l1.end()) == 2);
478 assert(l2.size() == 0);
479 assert(std::distance(l2.begin(), l2.end()) == 0);
480 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
481 assert(*i == 4);
482 ++i;
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.end(), l2);
489 assert(l1.size() == 2);
490 assert(std::distance(l1.begin(), l1.end()) == 2);
491 assert(l2.size() == 0);
492 assert(std::distance(l2.begin(), l2.end()) == 0);
493 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
494 assert(*i == 1);
495 ++i;
496 assert(*i == 4);
497 }
498 {
499 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
500 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
501 l1.splice(l1.begin(), l2);
502 assert(l1.size() == 3);
503 assert(std::distance(l1.begin(), l1.end()) == 3);
504 assert(l2.size() == 0);
505 assert(std::distance(l2.begin(), l2.end()) == 0);
506 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
507 assert(*i == 4);
508 ++i;
509 assert(*i == 5);
510 ++i;
511 assert(*i == 1);
512 }
513 {
514 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
515 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
516 l1.splice(l1.end(), l2);
517 assert(l1.size() == 3);
518 assert(std::distance(l1.begin(), l1.end()) == 3);
519 assert(l2.size() == 0);
520 assert(std::distance(l2.begin(), l2.end()) == 0);
521 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
522 assert(*i == 1);
523 ++i;
524 assert(*i == 4);
525 ++i;
526 assert(*i == 5);
527 }
528 {
529 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
530 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
531 l1.splice(l1.begin(), l2);
532 assert(l1.size() == 4);
533 assert(std::distance(l1.begin(), l1.end()) == 4);
534 assert(l2.size() == 0);
535 assert(std::distance(l2.begin(), l2.end()) == 0);
536 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
537 assert(*i == 4);
538 ++i;
539 assert(*i == 5);
540 ++i;
541 assert(*i == 6);
542 ++i;
543 assert(*i == 1);
544 }
545 {
546 std::list<int, min_allocator<int>> l1(a1, a1 + 1);
547 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
548 l1.splice(l1.end(), l2);
549 assert(l1.size() == 4);
550 assert(std::distance(l1.begin(), l1.end()) == 4);
551 assert(l2.size() == 0);
552 assert(std::distance(l2.begin(), l2.end()) == 0);
553 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
554 assert(*i == 1);
555 ++i;
556 assert(*i == 4);
557 ++i;
558 assert(*i == 5);
559 ++i;
560 assert(*i == 6);
561 }
562 {
563 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
564 std::list<int, min_allocator<int>> l2;
565 l1.splice(l1.begin(), l2);
566 assert(l1.size() == 2);
567 assert(std::distance(l1.begin(), l1.end()) == 2);
568 assert(l2.size() == 0);
569 assert(std::distance(l2.begin(), l2.end()) == 0);
570 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
571 assert(*i == 1);
572 ++i;
573 assert(*i == 2);
574 }
575 {
576 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
577 std::list<int, min_allocator<int>> l2;
578 l1.splice(std::next(l1.begin()), l2);
579 assert(l1.size() == 2);
580 assert(std::distance(l1.begin(), l1.end()) == 2);
581 assert(l2.size() == 0);
582 assert(std::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(std::next(l1.begin(), 2), l2);
592 assert(l1.size() == 2);
593 assert(std::distance(l1.begin(), l1.end()) == 2);
594 assert(l2.size() == 0);
595 assert(std::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(a2, a2 + 1);
604 l1.splice(l1.begin(), l2);
605 assert(l1.size() == 3);
606 assert(std::distance(l1.begin(), l1.end()) == 3);
607 assert(l2.size() == 0);
608 assert(std::distance(l2.begin(), l2.end()) == 0);
609 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
610 assert(*i == 4);
611 ++i;
612 assert(*i == 1);
613 ++i;
614 assert(*i == 2);
615 }
616 {
617 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
618 std::list<int, min_allocator<int>> l2(a2, a2 + 1);
619 l1.splice(std::next(l1.begin()), l2);
620 assert(l1.size() == 3);
621 assert(std::distance(l1.begin(), l1.end()) == 3);
622 assert(l2.size() == 0);
623 assert(std::distance(l2.begin(), l2.end()) == 0);
624 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
625 assert(*i == 1);
626 ++i;
627 assert(*i == 4);
628 ++i;
629 assert(*i == 2);
630 }
631 {
632 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
633 std::list<int, min_allocator<int>> l2(a2, a2 + 1);
634 l1.splice(std::next(l1.begin(), 2), l2);
635 assert(l1.size() == 3);
636 assert(std::distance(l1.begin(), l1.end()) == 3);
637 assert(l2.size() == 0);
638 assert(std::distance(l2.begin(), l2.end()) == 0);
639 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
640 assert(*i == 1);
641 ++i;
642 assert(*i == 2);
643 ++i;
644 assert(*i == 4);
645 }
646 {
647 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
648 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
649 l1.splice(l1.begin(), l2);
650 assert(l1.size() == 4);
651 assert(std::distance(l1.begin(), l1.end()) == 4);
652 assert(l2.size() == 0);
653 assert(std::distance(l2.begin(), l2.end()) == 0);
654 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
655 assert(*i == 4);
656 ++i;
657 assert(*i == 5);
658 ++i;
659 assert(*i == 1);
660 ++i;
661 assert(*i == 2);
662 }
663 {
664 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
665 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
666 l1.splice(std::next(l1.begin()), l2);
667 assert(l1.size() == 4);
668 assert(std::distance(l1.begin(), l1.end()) == 4);
669 assert(l2.size() == 0);
670 assert(std::distance(l2.begin(), l2.end()) == 0);
671 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
672 assert(*i == 1);
673 ++i;
674 assert(*i == 4);
675 ++i;
676 assert(*i == 5);
677 ++i;
678 assert(*i == 2);
679 }
680 {
681 std::list<int, min_allocator<int>> l1(a1, a1 + 2);
682 std::list<int, min_allocator<int>> l2(a2, a2 + 2);
683 l1.splice(std::next(l1.begin(), 2), l2);
684 assert(l1.size() == 4);
685 assert(std::distance(l1.begin(), l1.end()) == 4);
686 assert(l2.size() == 0);
687 assert(std::distance(l2.begin(), l2.end()) == 0);
688 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
689 assert(*i == 1);
690 ++i;
691 assert(*i == 2);
692 ++i;
693 assert(*i == 4);
694 ++i;
695 assert(*i == 5);
696 }
697 {
698 std::list<int, min_allocator<int>> l1(a1, a1 + 3);
699 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
700 l1.splice(l1.begin(), l2);
701 assert(l1.size() == 6);
702 assert(std::distance(l1.begin(), l1.end()) == 6);
703 assert(l2.size() == 0);
704 assert(std::distance(l2.begin(), l2.end()) == 0);
705 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
706 assert(*i == 4);
707 ++i;
708 assert(*i == 5);
709 ++i;
710 assert(*i == 6);
711 ++i;
712 assert(*i == 1);
713 ++i;
714 assert(*i == 2);
715 ++i;
716 assert(*i == 3);
717 }
718 {
719 std::list<int, min_allocator<int>> l1(a1, a1 + 3);
720 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
721 l1.splice(std::next(l1.begin()), l2);
722 assert(l1.size() == 6);
723 assert(std::distance(l1.begin(), l1.end()) == 6);
724 assert(l2.size() == 0);
725 assert(std::distance(l2.begin(), l2.end()) == 0);
726 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
727 assert(*i == 1);
728 ++i;
729 assert(*i == 4);
730 ++i;
731 assert(*i == 5);
732 ++i;
733 assert(*i == 6);
734 ++i;
735 assert(*i == 2);
736 ++i;
737 assert(*i == 3);
738 }
739 {
740 std::list<int, min_allocator<int>> l1(a1, a1 + 3);
741 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
742 l1.splice(std::next(l1.begin(), 2), l2);
743 assert(l1.size() == 6);
744 assert(std::distance(l1.begin(), l1.end()) == 6);
745 assert(l2.size() == 0);
746 assert(std::distance(l2.begin(), l2.end()) == 0);
747 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
748 assert(*i == 1);
749 ++i;
750 assert(*i == 2);
751 ++i;
752 assert(*i == 4);
753 ++i;
754 assert(*i == 5);
755 ++i;
756 assert(*i == 6);
757 ++i;
758 assert(*i == 3);
759 }
760 {
761 std::list<int, min_allocator<int>> l1(a1, a1 + 3);
762 std::list<int, min_allocator<int>> l2(a2, a2 + 3);
763 l1.splice(std::next(l1.begin(), 3), l2);
764 assert(l1.size() == 6);
765 assert(std::distance(l1.begin(), l1.end()) == 6);
766 assert(l2.size() == 0);
767 assert(std::distance(l2.begin(), l2.end()) == 0);
768 std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
769 assert(*i == 1);
770 ++i;
771 assert(*i == 2);
772 ++i;
773 assert(*i == 3);
774 ++i;
775 assert(*i == 4);
776 ++i;
777 assert(*i == 5);
778 ++i;
779 assert(*i == 6);
780 }
781#endif
782
783 return 0;
784}
785

source code of libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp