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