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 // template <class T, class Alloc>
13 // void swap(list<T,Alloc>& x, list<T,Alloc>& y);
14
15 #include <list>
16 #include <cassert>
17 #include "test_allocator.h"
18 #include "min_allocator.h"
19
main()20 int main()
21 {
22 {
23 int a1[] = {1, 3, 7, 9, 10};
24 int a2[] = {0, 2, 4, 5, 6, 8, 11};
25 std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
26 std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
27 swap(c1, c2);
28 assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
29 assert(c2 == std::list<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
30 }
31 {
32 int a1[] = {1, 3, 7, 9, 10};
33 int a2[] = {0, 2, 4, 5, 6, 8, 11};
34 std::list<int> c1(a1, a1);
35 std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
36 swap(c1, c2);
37 assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
38 assert(c2.empty());
39 assert(distance(c2.begin(), c2.end()) == 0);
40 }
41 {
42 int a1[] = {1, 3, 7, 9, 10};
43 int a2[] = {0, 2, 4, 5, 6, 8, 11};
44 std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
45 std::list<int> c2(a2, a2);
46 swap(c1, c2);
47 assert(c1.empty());
48 assert(distance(c1.begin(), c1.end()) == 0);
49 assert(c2 == std::list<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
50 }
51 {
52 int a1[] = {1, 3, 7, 9, 10};
53 int a2[] = {0, 2, 4, 5, 6, 8, 11};
54 std::list<int> c1(a1, a1);
55 std::list<int> c2(a2, a2);
56 swap(c1, c2);
57 assert(c1.empty());
58 assert(distance(c1.begin(), c1.end()) == 0);
59 assert(c2.empty());
60 assert(distance(c2.begin(), c2.end()) == 0);
61 }
62 #ifndef _LIBCPP_DEBUG_LEVEL
63 // This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
64 {
65 int a1[] = {1, 3, 7, 9, 10};
66 int a2[] = {0, 2, 4, 5, 6, 8, 11};
67 typedef test_allocator<int> A;
68 std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
69 std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
70 swap(c1, c2);
71 assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
72 assert(c1.get_allocator() == A(1));
73 assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
74 assert(c2.get_allocator() == A(2));
75 }
76 #endif
77 {
78 int a1[] = {1, 3, 7, 9, 10};
79 int a2[] = {0, 2, 4, 5, 6, 8, 11};
80 typedef other_allocator<int> A;
81 std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
82 std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
83 swap(c1, c2);
84 assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
85 assert(c1.get_allocator() == A(2));
86 assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
87 assert(c2.get_allocator() == A(1));
88 }
89 #if __cplusplus >= 201103L
90 {
91 int a1[] = {1, 3, 7, 9, 10};
92 int a2[] = {0, 2, 4, 5, 6, 8, 11};
93 std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
94 std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
95 swap(c1, c2);
96 assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
97 assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
98 }
99 {
100 int a1[] = {1, 3, 7, 9, 10};
101 int a2[] = {0, 2, 4, 5, 6, 8, 11};
102 std::list<int, min_allocator<int>> c1(a1, a1);
103 std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
104 swap(c1, c2);
105 assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
106 assert(c2.empty());
107 assert(distance(c2.begin(), c2.end()) == 0);
108 }
109 {
110 int a1[] = {1, 3, 7, 9, 10};
111 int a2[] = {0, 2, 4, 5, 6, 8, 11};
112 std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
113 std::list<int, min_allocator<int>> c2(a2, a2);
114 swap(c1, c2);
115 assert(c1.empty());
116 assert(distance(c1.begin(), c1.end()) == 0);
117 assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
118 }
119 {
120 int a1[] = {1, 3, 7, 9, 10};
121 int a2[] = {0, 2, 4, 5, 6, 8, 11};
122 std::list<int, min_allocator<int>> c1(a1, a1);
123 std::list<int, min_allocator<int>> c2(a2, a2);
124 swap(c1, c2);
125 assert(c1.empty());
126 assert(distance(c1.begin(), c1.end()) == 0);
127 assert(c2.empty());
128 assert(distance(c2.begin(), c2.end()) == 0);
129 }
130 #ifndef _LIBCPP_DEBUG_LEVEL
131 // This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
132 {
133 int a1[] = {1, 3, 7, 9, 10};
134 int a2[] = {0, 2, 4, 5, 6, 8, 11};
135 typedef min_allocator<int> A;
136 std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
137 std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
138 swap(c1, c2);
139 assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
140 assert(c1.get_allocator() == A());
141 assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
142 assert(c2.get_allocator() == A());
143 }
144 #endif
145 #endif
146 }
147