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, iterator first, iterator last);
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
23int main()
24{
25    int a1[] = {1, 2, 3};
26    int a2[] = {4, 5, 6};
27    {
28        std::list<int> l1(a1, a1+3);
29        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
30        assert(l1.size() == 3);
31        assert(distance(l1.begin(), l1.end()) == 3);
32        std::list<int>::const_iterator i = l1.begin();
33        assert(*i == 1);
34        ++i;
35        assert(*i == 2);
36        ++i;
37        assert(*i == 3);
38    }
39    {
40        std::list<int> l1(a1, a1+3);
41        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
42        assert(l1.size() == 3);
43        assert(distance(l1.begin(), l1.end()) == 3);
44        std::list<int>::const_iterator i = l1.begin();
45        assert(*i == 2);
46        ++i;
47        assert(*i == 1);
48        ++i;
49        assert(*i == 3);
50    }
51    {
52        std::list<int> l1(a1, a1+3);
53        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
54        assert(l1.size() == 3);
55        assert(distance(l1.begin(), l1.end()) == 3);
56        std::list<int>::const_iterator i = l1.begin();
57        assert(*i == 2);
58        ++i;
59        assert(*i == 3);
60        ++i;
61        assert(*i == 1);
62    }
63    {
64        std::list<int> l1(a1, a1+3);
65        std::list<int> l2(a2, a2+3);
66        l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
67        assert(l1.size() == 5);
68        assert(distance(l1.begin(), l1.end()) == 5);
69        std::list<int>::const_iterator i = l1.begin();
70        assert(*i == 5);
71        ++i;
72        assert(*i == 6);
73        ++i;
74        assert(*i == 1);
75        ++i;
76        assert(*i == 2);
77        ++i;
78        assert(*i == 3);
79        assert(l2.size() == 1);
80        i = l2.begin();
81        assert(*i == 4);
82    }
83    {
84        std::list<int> l1(a1, a1+3);
85        std::list<int> l2(a2, a2+3);
86        l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
87        assert(l1.size() == 5);
88        assert(distance(l1.begin(), l1.end()) == 5);
89        std::list<int>::const_iterator i = l1.begin();
90        assert(*i == 1);
91        ++i;
92        assert(*i == 5);
93        ++i;
94        assert(*i == 6);
95        ++i;
96        assert(*i == 2);
97        ++i;
98        assert(*i == 3);
99        assert(l2.size() == 1);
100        i = l2.begin();
101        assert(*i == 4);
102    }
103    {
104        std::list<int> l1(a1, a1+3);
105        std::list<int> l2(a2, a2+3);
106        l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
107        assert(l1.size() == 5);
108        assert(distance(l1.begin(), l1.end()) == 5);
109        std::list<int>::const_iterator i = l1.begin();
110        assert(*i == 1);
111        ++i;
112        assert(*i == 2);
113        ++i;
114        assert(*i == 3);
115        ++i;
116        assert(*i == 5);
117        ++i;
118        assert(*i == 6);
119        assert(l2.size() == 1);
120        i = l2.begin();
121        assert(*i == 4);
122    }
123#if _LIBCPP_DEBUG >= 1
124    {
125        std::list<int> v1(3);
126        std::list<int> v2(3);
127        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
128        assert(false);
129    }
130#endif
131#if __cplusplus >= 201103L
132    {
133        std::list<int, min_allocator<int>> l1(a1, a1+3);
134        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
135        assert(l1.size() == 3);
136        assert(distance(l1.begin(), l1.end()) == 3);
137        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
138        assert(*i == 1);
139        ++i;
140        assert(*i == 2);
141        ++i;
142        assert(*i == 3);
143    }
144    {
145        std::list<int, min_allocator<int>> l1(a1, a1+3);
146        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
147        assert(l1.size() == 3);
148        assert(distance(l1.begin(), l1.end()) == 3);
149        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
150        assert(*i == 2);
151        ++i;
152        assert(*i == 1);
153        ++i;
154        assert(*i == 3);
155    }
156    {
157        std::list<int, min_allocator<int>> l1(a1, a1+3);
158        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
159        assert(l1.size() == 3);
160        assert(distance(l1.begin(), l1.end()) == 3);
161        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
162        assert(*i == 2);
163        ++i;
164        assert(*i == 3);
165        ++i;
166        assert(*i == 1);
167    }
168    {
169        std::list<int, min_allocator<int>> l1(a1, a1+3);
170        std::list<int, min_allocator<int>> l2(a2, a2+3);
171        l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
172        assert(l1.size() == 5);
173        assert(distance(l1.begin(), l1.end()) == 5);
174        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
175        assert(*i == 5);
176        ++i;
177        assert(*i == 6);
178        ++i;
179        assert(*i == 1);
180        ++i;
181        assert(*i == 2);
182        ++i;
183        assert(*i == 3);
184        assert(l2.size() == 1);
185        i = l2.begin();
186        assert(*i == 4);
187    }
188    {
189        std::list<int, min_allocator<int>> l1(a1, a1+3);
190        std::list<int, min_allocator<int>> l2(a2, a2+3);
191        l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
192        assert(l1.size() == 5);
193        assert(distance(l1.begin(), l1.end()) == 5);
194        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
195        assert(*i == 1);
196        ++i;
197        assert(*i == 5);
198        ++i;
199        assert(*i == 6);
200        ++i;
201        assert(*i == 2);
202        ++i;
203        assert(*i == 3);
204        assert(l2.size() == 1);
205        i = l2.begin();
206        assert(*i == 4);
207    }
208    {
209        std::list<int, min_allocator<int>> l1(a1, a1+3);
210        std::list<int, min_allocator<int>> l2(a2, a2+3);
211        l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
212        assert(l1.size() == 5);
213        assert(distance(l1.begin(), l1.end()) == 5);
214        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
215        assert(*i == 1);
216        ++i;
217        assert(*i == 2);
218        ++i;
219        assert(*i == 3);
220        ++i;
221        assert(*i == 5);
222        ++i;
223        assert(*i == 6);
224        assert(l2.size() == 1);
225        i = l2.begin();
226        assert(*i == 4);
227    }
228#if _LIBCPP_DEBUG >= 1
229    {
230        std::list<int, min_allocator<int>> v1(3);
231        std::list<int, min_allocator<int>> v2(3);
232        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
233        assert(false);
234    }
235#endif
236#endif
237}
238