111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//===----------------------------------------------------------------------===// 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The LLVM Compiler Infrastructure 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This file is dual licensed under the MIT and the University of Illinois Open 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Source Licenses. See LICENSE.TXT for details. 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//===----------------------------------------------------------------------===// 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <forward_list> 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// template <class T, class Allocator> 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y); 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <forward_list> 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <cassert> 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "test_allocator.h" 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "min_allocator.h" 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint main() 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<T> A; 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A(1)); 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A(2)); 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(1)); 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(2)); 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<T> A; 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A(1)); 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A(2)); 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(1)); 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(2)); 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<T> A; 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A(1)); 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A(2)); 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(1)); 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(2)); 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<T> A; 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A(1)); 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A(2)); 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(1)); 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(2)); 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<T> A; 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A(1)); 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A(2)); 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(2)); 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(1)); 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<T> A; 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A(1)); 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A(2)); 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(2)); 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(1)); 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<T> A; 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A(1)); 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A(2)); 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(2)); 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(1)); 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<T> A; 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A(1)); 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A(2)); 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A(2)); 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A(1)); 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if __cplusplus >= 201103L 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<T> A; 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A()); 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A()); 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A()); 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A()); 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<T> A; 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t1[] = {0, 1, 2, 3, 4, 5}; 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(t1), std::end(t1), A()); 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A{}); 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A()); 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 6); 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 0) == 0); 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 1) == 1); 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 2) == 2); 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 3) == 3); 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 4) == 4); 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c2.begin(), 5) == 5); 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A()); 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<T> A; 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A{}); 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T t2[] = {10, 11, 12}; 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(t2), std::end(t2), A()); 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 3); 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 0) == 10); 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 1) == 11); 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(*next(c1.begin(), 2) == 12); 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A()); 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A()); 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int T; 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<T> A; 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::forward_list<T, A> C; 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(A{}); 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(A{}); 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c1.begin(), c1.end()) == 0); 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == A()); 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(distance(c2.begin(), c2.end()) == 0); 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == A()); 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 261