1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// This file is dual licensed under the MIT and the University of Illinois Open 6b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// Source Licenses. See LICENSE.TXT for details. 7bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 8bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 9bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 10bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// <list> 11bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 12bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// void splice(const_iterator position, list& x); 13bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 145e57142c5902c3f73a6fdcb8cab55e88ffb43a56Howard Hinnant#if _LIBCPP_DEBUG >= 1 152062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) 162062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant#endif 172062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant 18bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <list> 19bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <cassert> 20bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 21061d0cc4db18d17bf01ed14c5db0be098205bd47Marshall Clow#include "min_allocator.h" 2229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant 23bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 24bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 25bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int a1[] = {1, 2, 3}; 26bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int a2[] = {4, 5, 6}; 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1; 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 0); 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 0); 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 35bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 36bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1; 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 40bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 1); 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1; 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 1); 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 85bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 1); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 108bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 109bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 131bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 132bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 149bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 150bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 4); 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 168bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+1); 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.end(), l2); 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 4); 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin()), l2); 204bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 205bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 206bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 207bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 208bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 209bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 210bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 211bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 212bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 213bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 215bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2; 216bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 217bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 2); 218bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 219bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 220bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 221bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 222bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 223bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 224bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 225bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 226bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 229bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 230bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 231bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 232bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 233bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 234bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 235bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 236bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 237bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 238bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 239bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 240bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 241bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 242bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 243bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 244bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin()), l2); 245bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 246bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 247bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 248bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 249bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 250bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 251bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 252bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 253bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 254bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 255bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 256bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 257bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 258bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+1); 259bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 260bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 3); 261bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 262bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 263bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 264bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 265bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 266bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 267bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 268bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 269bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 270bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 271bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 272bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 273bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 274bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 4); 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 277bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 278bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 279bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 280bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 281bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 282bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 283bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 284bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 285bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 286bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 287bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 288bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 289bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 290bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 291bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin()), l2); 292bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 4); 293bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 294bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 295bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 296bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 297bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 298bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 299bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 300bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 301bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 302bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 303bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 304bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 305bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 306bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+2); 307bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+2); 308bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 309bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 4); 310bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 311bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 312bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 315bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 316bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 317bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 318bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 319bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 320bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 321bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 322bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 323bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+3); 324bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 325bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(l1.begin(), l2); 326bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 6); 327bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 328bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 329bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 330bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 331bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 332bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 333bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 334bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 335bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 336bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 337bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 338bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 339bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 340bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 341bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 3); 342bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 343bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 344bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+3); 345bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 346bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin()), l2); 347bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 6); 348bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 349bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 350bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 351bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 352bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 353bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 354bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 355bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 356bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 357bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 358bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 359bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 360bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 361bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 362bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 3); 363bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 364bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 365bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+3); 366bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 367bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 368bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 6); 369bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 370bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 371bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 372bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 373bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 376bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 377bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 378bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 379bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 380bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 381bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 382bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 383bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 3); 384bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 385bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 386bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l1(a1, a1+3); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int> l2(a2, a2+3); 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant l1.splice(next(l1.begin(), 3), l2); 389bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l1.size() == 6); 390bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 391bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(l2.size() == 0); 392bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 393bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::list<int>::const_iterator i = l1.begin(); 394bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 1); 395bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 396bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 2); 397bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 398bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 3); 399bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 400bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 4); 401bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 402bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 5); 403bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++i; 404bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*i == 6); 405bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 4065e57142c5902c3f73a6fdcb8cab55e88ffb43a56Howard Hinnant#if _LIBCPP_DEBUG >= 1 4072062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant { 4082062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant std::list<int> v1(3); 4092062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant std::list<int> v2(3); 4102062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant v1.splice(v2.begin(), v2); 4112062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant assert(false); 4122062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant } 4132062f377728e6c2a77842ca5b2c6428aab605ebcHoward Hinnant#endif 41429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant#if __cplusplus >= 201103L 41529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 41629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1; 41729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 41829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 41929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 0); 42029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 0); 42129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 42229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 42329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 42429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 42529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1; 42629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 42729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 42829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 1); 42929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 43029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 43129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 43229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 43329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 43429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 43529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 43629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1; 43729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 43829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 43929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 44029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 44129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 44229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 44329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 44429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 44529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 44629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 44729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 44829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 44929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1; 45029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 45129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 45229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 45329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 45429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 45529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 45629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 45729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 45829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 45929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 46029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 46129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 46229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 46329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 46429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 46529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 46629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 46729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 1); 46829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 46929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 47029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 47129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 47229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 47329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 47429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 47529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 47629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 47729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 47829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 1); 47929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 1); 48029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 48129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 48229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 48329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 48429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 48529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 48629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 48729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 48829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 48929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 49029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 49129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 49229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 49329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 49429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 49529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 49629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 49729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 49829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 49929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 50029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 50129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 50229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 50329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 50429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 50529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 50629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 50729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 50829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 50929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 51029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 51129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 51229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 51329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 51429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 51529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 51629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 51729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 51829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 51929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 52029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 52129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 52229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 52329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 52429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 52529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 52629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 52729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 52829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 52929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 53029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 53129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 53229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 53329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 53429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 53529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 53629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 53729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 53829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 53929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 54029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 54129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 54229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 54329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 54429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 54529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 4); 54629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 54729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 54829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 54929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 55029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 55129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 55229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 55329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 55429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 55529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 55629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 55729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 55829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 55929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+1); 56029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 56129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.end(), l2); 56229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 4); 56329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 56429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 56529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 56629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 56729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 56829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 56929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 57029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 57129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 57229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 57329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 57429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 57529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 57629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 57729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 57829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 57929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 58029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 58129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 58229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 58329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 58429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 58529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 58629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 58729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 58829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 58929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 59029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 59129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin()), l2); 59229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 59329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 59429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 59529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 59629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 59729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 59829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 59929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 60029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 60129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 60229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 60329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2; 60429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 60529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 2); 60629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 2); 60729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 60829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 60929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 61029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 61129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 61229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 61329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 61429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 61529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 61629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 61729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 61829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 61929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 62029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 62129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 62229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 62329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 62429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 62529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 62629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 62729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 62829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 62929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 63029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 63129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 63229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin()), l2); 63329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 63429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 63529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 63629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 63729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 63829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 63929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 64029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 64129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 64229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 64329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 64429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 64529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 64629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+1); 64729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 64829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 3); 64929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 3); 65029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 65129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 65229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 65329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 65429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 65529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 65629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 65729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 65829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 65929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 66029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 66129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 66229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 66329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 4); 66429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 66529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 66629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 66729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 66829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 66929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 67029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 67129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 67229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 67329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 67429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 67529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 67629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 67729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 67829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 67929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin()), l2); 68029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 4); 68129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 68229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 68329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 68429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 68529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 68629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 68729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 68829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 68929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 69029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 69129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 69229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 69329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 69429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+2); 69529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+2); 69629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 69729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 4); 69829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 4); 69929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 70029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 70129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 70229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 70329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 70429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 70529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 70629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 70729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 70829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 70929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 71029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 71129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+3); 71229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 71329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(l1.begin(), l2); 71429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 6); 71529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 71629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 71729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 71829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 71929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 72029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 72129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 72229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 72329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 72429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 72529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 72629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 72729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 72829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 72929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 3); 73029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 73129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 73229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+3); 73329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 73429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin()), l2); 73529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 6); 73629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 73729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 73829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 73929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 74029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 74129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 74229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 74329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 74429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 74529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 74629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 74729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 74829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 74929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 75029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 3); 75129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 75229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 75329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+3); 75429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 75529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin(), 2), l2); 75629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 6); 75729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 75829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 75929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 76029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 76129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 76229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 76329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 76429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 76529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 76629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 76729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 76829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 76929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 77029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 77129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 3); 77229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 77329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 77429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l1(a1, a1+3); 77529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> l2(a2, a2+3); 77629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant l1.splice(next(l1.begin(), 3), l2); 77729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l1.size() == 6); 77829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l1.begin(), l1.end()) == 6); 77929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(l2.size() == 0); 78029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(distance(l2.begin(), l2.end()) == 0); 78129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>>::const_iterator i = l1.begin(); 78229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 1); 78329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 78429f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 2); 78529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 78629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 3); 78729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 78829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 4); 78929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 79029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 5); 79129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant ++i; 79229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(*i == 6); 79329f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 7945e57142c5902c3f73a6fdcb8cab55e88ffb43a56Howard Hinnant#if _LIBCPP_DEBUG >= 1 79529f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant { 79629f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> v1(3); 79729f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant std::list<int, min_allocator<int>> v2(3); 79829f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant v1.splice(v2.begin(), v2); 79929f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant assert(false); 80029f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant } 80129f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant#endif 80229f7432ff3a5c503a98a66ae46dd571b651c88b5Howard Hinnant#endif 803bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 804