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