1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // <vector>
10 
11 // template <class T, class Alloc>
12 //   void swap(vector<T,Alloc>& x, vector<T,Alloc>& y);
13 
14 #include <vector>
15 #include <iterator>
16 #include <cassert>
17 #include "test_allocator.h"
18 #include "min_allocator.h"
19 #include "asan_testing.h"
20 
21 int main(int, char**)
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     {
80         int a1[] = {1, 3, 7, 9, 10};
81         int a2[] = {0, 2, 4, 5, 6, 8, 11};
82         typedef test_allocator<int> A;
83         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1, 1));
84         std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(1, 2));
85         swap(c1, c2);
86         assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
87         assert(c1.get_allocator().get_id() == 1);
88         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
89         assert(c2.get_allocator().get_id() == 2);
90     }
91     {
92         int a1[] = {1, 3, 7, 9, 10};
93         int a2[] = {0, 2, 4, 5, 6, 8, 11};
94         typedef other_allocator<int> A;
95         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
96         std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
97         assert(is_contiguous_container_asan_correct(c1));
98         assert(is_contiguous_container_asan_correct(c2));
99         swap(c1, c2);
100         assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
101         assert(c1.get_allocator() == A(2));
102         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
103         assert(c2.get_allocator() == A(1));
104         assert(is_contiguous_container_asan_correct(c1));
105         assert(is_contiguous_container_asan_correct(c2));
106     }
107 #if TEST_STD_VER >= 11
108     {
109         int a1[] = {1, 3, 7, 9, 10};
110         int a2[] = {0, 2, 4, 5, 6, 8, 11};
111         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
112         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
113         assert(is_contiguous_container_asan_correct(c1));
114         assert(is_contiguous_container_asan_correct(c2));
115         swap(c1, c2);
116         assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
117         assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
118         assert(is_contiguous_container_asan_correct(c1));
119         assert(is_contiguous_container_asan_correct(c2));
120     }
121     {
122         int a1[] = {1, 3, 7, 9, 10};
123         int a2[] = {0, 2, 4, 5, 6, 8, 11};
124         std::vector<int, min_allocator<int>> c1(a1, a1);
125         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
126         assert(is_contiguous_container_asan_correct(c1));
127         assert(is_contiguous_container_asan_correct(c2));
128         swap(c1, c2);
129         assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
130         assert(c2.empty());
131         assert(distance(c2.begin(), c2.end()) == 0);
132         assert(is_contiguous_container_asan_correct(c1));
133         assert(is_contiguous_container_asan_correct(c2));
134     }
135     {
136         int a1[] = {1, 3, 7, 9, 10};
137         int a2[] = {0, 2, 4, 5, 6, 8, 11};
138         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
139         std::vector<int, min_allocator<int>> c2(a2, a2);
140         assert(is_contiguous_container_asan_correct(c1));
141         assert(is_contiguous_container_asan_correct(c2));
142         swap(c1, c2);
143         assert(c1.empty());
144         assert(distance(c1.begin(), c1.end()) == 0);
145         assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
146         assert(is_contiguous_container_asan_correct(c1));
147         assert(is_contiguous_container_asan_correct(c2));
148     }
149     {
150         int a1[] = {1, 3, 7, 9, 10};
151         int a2[] = {0, 2, 4, 5, 6, 8, 11};
152         std::vector<int, min_allocator<int>> c1(a1, a1);
153         std::vector<int, min_allocator<int>> c2(a2, a2);
154         assert(is_contiguous_container_asan_correct(c1));
155         assert(is_contiguous_container_asan_correct(c2));
156         swap(c1, c2);
157         assert(c1.empty());
158         assert(distance(c1.begin(), c1.end()) == 0);
159         assert(c2.empty());
160         assert(distance(c2.begin(), c2.end()) == 0);
161         assert(is_contiguous_container_asan_correct(c1));
162         assert(is_contiguous_container_asan_correct(c2));
163     }
164     {
165         int a1[] = {1, 3, 7, 9, 10};
166         int a2[] = {0, 2, 4, 5, 6, 8, 11};
167         typedef min_allocator<int> A;
168         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
169         std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
170         assert(is_contiguous_container_asan_correct(c1));
171         assert(is_contiguous_container_asan_correct(c2));
172         swap(c1, c2);
173         assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
174         assert(c1.get_allocator() == A());
175         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
176         assert(c2.get_allocator() == A());
177         assert(is_contiguous_container_asan_correct(c1));
178         assert(is_contiguous_container_asan_correct(c2));
179     }
180 #endif
181 
182   return 0;
183 }
184