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

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