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

source code of libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp