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 
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