]>
Commit | Line | Data |
---|---|---|
a5544970 | 1 | // Copyright (C) 2015-2019 Free Software Foundation, Inc. |
6b9539e2 DK |
2 | // |
3 | // This file is part of the GNU ISO C++ Library. This library is free | |
4 | // software; you can redistribute it and/or modify it under the | |
5 | // terms of the GNU General Public License as published by the | |
6 | // Free Software Foundation; either version 3, or (at your option) | |
7 | // any later version. | |
8 | // | |
9 | // This library is distributed in the hope that it will be useful, | |
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | // GNU General Public License for more details. | |
13 | // | |
14 | // You should have received a copy of the GNU General Public License along | |
15 | // with this library; see the file COPYING3. If not see | |
16 | // <http://www.gnu.org/licenses/>. | |
17 | ||
18 | #include <type_traits> | |
19 | #include <testsuite_tr1.h> | |
20 | #include <utility> | |
21 | #include <array> | |
22 | #include <tuple> | |
23 | #include <queue> | |
24 | #include <stack> | |
25 | ||
26 | #if defined(test_std_is_nothrow_swappable) | |
27 | # ifndef __cpp_lib_is_swappable | |
28 | # error "Feature-test macro for is_nothrow_swappable missing" | |
29 | # elif __cpp_lib_is_swappable != 201603 | |
30 | # error "Feature-test macro for is_nothrow_swappable has wrong value" | |
31 | # endif | |
32 | // Test std::is_nothrow_swappable: | |
33 | template<class T> | |
34 | using is_nothrow_swappable = std::is_nothrow_swappable<T>; | |
35 | #elif defined(test_std_is_nothrow_swappable_ext) | |
36 | // Test our __is_nothrow_swappable extension: | |
37 | template<class T> | |
38 | using is_nothrow_swappable = std::__is_nothrow_swappable<T>; | |
39 | #else | |
40 | # error "Either test_std_is_nothrow_swappable or " \ | |
41 | "test_std_is_nothrow_swappable_ext need to be defined" | |
42 | #endif | |
43 | ||
44 | namespace funny { | |
45 | struct F {}; | |
46 | void swap(F&, F&) = delete; | |
47 | void swap(F(&)[5], F(&)[5]) noexcept; | |
48 | void swap(F(&)[6], F(&)[6]); | |
49 | struct A {}; | |
50 | void swap(A&, A&) noexcept(false); | |
51 | } | |
52 | namespace std { | |
53 | template<> | |
54 | void swap<funny::A>(funny::A&, funny::A&) noexcept | |
55 | { | |
56 | } | |
57 | ||
58 | template<> | |
59 | void swap<funny::A>(funny::A(&)[3], funny::A(&)[3]) noexcept(false) | |
60 | { | |
61 | } | |
62 | } | |
63 | namespace ns1 { | |
64 | struct SwapThrow {}; | |
65 | void swap(SwapThrow&, SwapThrow&); | |
66 | void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept; | |
67 | } | |
68 | ||
69 | namespace ns2 { | |
70 | struct SwapThrow { | |
71 | SwapThrow() noexcept = default; | |
72 | SwapThrow(const SwapThrow&) noexcept(false); | |
73 | SwapThrow& operator=(const SwapThrow&) noexcept(false); | |
74 | }; | |
75 | } | |
76 | ||
77 | namespace ns3 { | |
78 | struct SwapNoThrow { | |
79 | SwapNoThrow() noexcept = default; | |
80 | SwapNoThrow(const SwapNoThrow&) noexcept(false); | |
81 | SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false); | |
82 | }; | |
83 | void swap(SwapNoThrow&, SwapNoThrow&) noexcept; | |
84 | } | |
85 | ||
86 | namespace ns4 { | |
87 | struct SwapNoThrow {}; | |
88 | } | |
89 | ||
90 | namespace ns5 { | |
91 | struct SwapThrow { | |
92 | SwapThrow() noexcept = default; | |
93 | SwapThrow(SwapThrow&&) noexcept; | |
94 | SwapThrow& operator=(const SwapThrow&) noexcept(false); | |
95 | }; | |
96 | } | |
97 | ||
98 | namespace comps { | |
99 | struct CompareNoThrowCopyable | |
100 | { | |
101 | template<class T> | |
102 | bool operator()(const T&, const T&) const | |
103 | { return false; } | |
104 | }; | |
105 | ||
106 | struct CompareNonCopyable | |
107 | { | |
108 | CompareNonCopyable() = default; | |
109 | CompareNonCopyable(const CompareNonCopyable&) = delete; | |
110 | CompareNonCopyable& operator=(const CompareNonCopyable&) noexcept; | |
111 | ||
112 | template<class T> | |
113 | bool operator()(const T&, const T&) const | |
114 | { return false; } | |
115 | }; | |
116 | ||
117 | struct CompareThrowCopyable | |
118 | { | |
119 | CompareThrowCopyable() = default; | |
120 | CompareThrowCopyable(const CompareThrowCopyable&) noexcept(false); | |
121 | CompareThrowCopyable& operator=(const CompareThrowCopyable&); | |
122 | ||
123 | template<class T> | |
124 | bool operator()(const T&, const T&) const | |
125 | { return false; } | |
126 | }; | |
127 | } | |
128 | ||
129 | void test01() | |
130 | { | |
131 | using namespace __gnu_test; | |
132 | // Positive tests. | |
133 | static_assert(test_property<is_nothrow_swappable, int>(true), ""); | |
134 | static_assert(test_property<is_nothrow_swappable, bool>(true), ""); | |
135 | static_assert(test_property<is_nothrow_swappable, | |
136 | decltype(nullptr)>(true), ""); | |
137 | static_assert(test_property<is_nothrow_swappable, int&>(true), ""); | |
138 | static_assert(test_property<is_nothrow_swappable, int&&>(true), ""); | |
139 | static_assert(test_property<is_nothrow_swappable, int[1]>(true), ""); | |
140 | static_assert(test_property<is_nothrow_swappable, int[1][2]>(true), ""); | |
141 | static_assert(test_property<is_nothrow_swappable, int[1][2][3]>(true), ""); | |
142 | static_assert(test_property<is_nothrow_swappable, funny::F[5]>(true), ""); | |
143 | static_assert(test_property<is_nothrow_swappable, EnumType>(true), ""); | |
144 | static_assert(test_property<is_nothrow_swappable, PODType>(true), ""); | |
145 | static_assert(test_property<is_nothrow_swappable, UnionType>(true), ""); | |
146 | static_assert(test_property<is_nothrow_swappable, | |
147 | construct::SE>(true), ""); | |
148 | static_assert(test_property<is_nothrow_swappable, | |
149 | construct::Empty>(true), ""); | |
150 | static_assert(test_property<is_nothrow_swappable, void*>(true), ""); | |
151 | static_assert(test_property<is_nothrow_swappable, void(*)()>(true), ""); | |
152 | static_assert(test_property<is_nothrow_swappable, int const*>(true), ""); | |
153 | static_assert(test_property<is_nothrow_swappable, ClassType*>(true), ""); | |
154 | static_assert(test_property<is_nothrow_swappable, | |
155 | int ClassType::*>(true), ""); | |
156 | static_assert(test_property<is_nothrow_swappable, | |
157 | void (ClassType::*)()>(true), ""); | |
158 | static_assert(test_property<is_nothrow_swappable, | |
159 | int (ClassType::*)() const volatile>(true), ""); | |
160 | static_assert(test_property<is_nothrow_swappable, | |
161 | ns1::SwapThrow[3]>(true), ""); | |
162 | static_assert(!noexcept(std::swap(std::declval<ns1::SwapThrow(&)[3]>(), | |
163 | std::declval<ns1::SwapThrow(&)[3]>())), | |
164 | ""); | |
165 | static_assert(test_property<is_nothrow_swappable, | |
166 | ns3::SwapNoThrow>(true), ""); | |
167 | static_assert(!noexcept(std::swap(std::declval<ns3::SwapNoThrow&>(), | |
168 | std::declval<ns3::SwapNoThrow&>())), ""); | |
169 | static_assert(test_property<is_nothrow_swappable, | |
170 | ns3::SwapNoThrow[1]>(true), ""); | |
171 | static_assert(test_property<is_nothrow_swappable, | |
172 | ns3::SwapNoThrow[3]>(true), ""); | |
173 | static_assert(test_property<is_nothrow_swappable, | |
174 | ns3::SwapNoThrow[2][3][4]>(true), ""); | |
175 | static_assert(test_property<is_nothrow_swappable, | |
176 | ns4::SwapNoThrow>(true), ""); | |
177 | static_assert(test_property<is_nothrow_swappable, | |
178 | ns4::SwapNoThrow[1]>(true), ""); | |
179 | static_assert(test_property<is_nothrow_swappable, | |
180 | ns4::SwapNoThrow[3]>(true), ""); | |
181 | static_assert(test_property<is_nothrow_swappable, | |
182 | ns4::SwapNoThrow[2][3][4]>(true), ""); | |
183 | static_assert(test_property<is_nothrow_swappable, | |
184 | std::pair<int, int>>(true), ""); | |
185 | static_assert(test_property<is_nothrow_swappable, | |
186 | std::pair<int, int>[1]>(true), ""); | |
187 | static_assert(test_property<is_nothrow_swappable, | |
188 | std::pair<int, int>[1][2]>(true), ""); | |
189 | static_assert(test_property<is_nothrow_swappable, | |
190 | std::tuple<int>>(true), ""); | |
191 | static_assert(test_property<is_nothrow_swappable, | |
192 | std::tuple<int>[1]>(true), ""); | |
193 | static_assert(test_property<is_nothrow_swappable, | |
194 | std::tuple<int>[1][2]>(true), ""); | |
195 | static_assert(test_property<is_nothrow_swappable, | |
196 | std::tuple<>>(true), ""); | |
197 | static_assert(test_property<is_nothrow_swappable, | |
198 | std::tuple<>[1]>(true), ""); | |
199 | static_assert(test_property<is_nothrow_swappable, | |
200 | std::tuple<>[1][2]>(true), ""); | |
201 | static_assert(test_property<is_nothrow_swappable, | |
202 | std::array<int, 1>>(true), ""); | |
203 | static_assert(test_property<is_nothrow_swappable, | |
204 | std::array<int, 0>>(true), ""); | |
205 | static_assert(test_property<is_nothrow_swappable, | |
206 | std::array<construct::DelCopy, 0>>(true), ""); | |
207 | static_assert(test_property<is_nothrow_swappable, | |
208 | std::array<ns1::SwapThrow, 0>>(true), ""); | |
209 | static_assert(test_property<is_nothrow_swappable, | |
210 | std::queue<int>>(true), ""); | |
211 | static_assert(test_property<is_nothrow_swappable, | |
212 | std::priority_queue<int>>(true), ""); | |
213 | static_assert(test_property<is_nothrow_swappable, | |
214 | std::stack<int>>(true), ""); | |
215 | static_assert(test_property<is_nothrow_swappable, | |
216 | std::priority_queue<int, std::vector<int>, | |
217 | comps::CompareNoThrowCopyable>>(true), ""); | |
218 | ||
219 | // Negative tests. | |
220 | static_assert(test_property<is_nothrow_swappable, void>(false), ""); | |
221 | static_assert(test_property<is_nothrow_swappable, const void>(false), ""); | |
222 | static_assert(test_property<is_nothrow_swappable, void()>(false), ""); | |
223 | static_assert(test_property<is_nothrow_swappable, | |
224 | void() const>(false), ""); | |
225 | static_assert(test_property<is_nothrow_swappable, | |
226 | void() volatile>(false), ""); | |
227 | static_assert(test_property<is_nothrow_swappable, | |
228 | void() const volatile>(false), ""); | |
229 | static_assert(test_property<is_nothrow_swappable, const int>(false), ""); | |
230 | static_assert(test_property<is_nothrow_swappable, const bool>(false), ""); | |
231 | static_assert(test_property<is_nothrow_swappable, | |
232 | const int[1]>(false), ""); | |
233 | static_assert(test_property<is_nothrow_swappable, | |
234 | const int[1][2]>(false), ""); | |
235 | static_assert(test_property<is_nothrow_swappable, | |
236 | const int[1][2][3]>(false), ""); | |
237 | static_assert(test_property<is_nothrow_swappable, int[]>(false), ""); | |
238 | static_assert(test_property<is_nothrow_swappable, const int[]>(false), ""); | |
239 | static_assert(test_property<is_nothrow_swappable, int[][1]>(false), ""); | |
240 | static_assert(test_property<is_nothrow_swappable, | |
241 | const funny::F[5]>(false), ""); | |
242 | static_assert(test_property<is_nothrow_swappable, | |
243 | construct::Abstract>(false), ""); | |
244 | static_assert(test_property<is_nothrow_swappable, | |
245 | construct::DelCopy>(false), ""); | |
246 | static_assert(test_property<is_nothrow_swappable, funny::F>(false), ""); | |
247 | static_assert(test_property<is_nothrow_swappable, funny::F[1]>(false), ""); | |
248 | static_assert(test_property<is_nothrow_swappable, | |
249 | funny::F[1][2]>(false), ""); | |
250 | static_assert(test_property<is_nothrow_swappable, | |
251 | funny::F[1][2][3]>(false), ""); | |
252 | static_assert(test_property<is_nothrow_swappable, funny::F[6]>(false), ""); | |
253 | static_assert(test_property<is_nothrow_swappable, funny::A>(false), ""); | |
254 | static_assert(noexcept(std::swap(std::declval<funny::A&>(), | |
255 | std::declval<funny::A&>())), ""); | |
256 | static_assert(test_property<is_nothrow_swappable, funny::A[3]>(false), ""); | |
257 | static_assert(test_property<is_nothrow_swappable, | |
258 | ns1::SwapThrow>(false), ""); | |
259 | static_assert(test_property<is_nothrow_swappable, | |
260 | ns1::SwapThrow[1]>(false), ""); | |
261 | static_assert(test_property<is_nothrow_swappable, | |
262 | ns1::SwapThrow[3][2]>(false), ""); | |
263 | static_assert(test_property<is_nothrow_swappable, | |
264 | ns1::SwapThrow[2][3][4]>(false), ""); | |
265 | static_assert(test_property<is_nothrow_swappable, | |
266 | ns2::SwapThrow>(false), ""); | |
267 | static_assert(test_property<is_nothrow_swappable, | |
268 | ns2::SwapThrow[1]>(false), ""); | |
269 | static_assert(test_property<is_nothrow_swappable, | |
270 | ns2::SwapThrow[2][3][4]>(false), ""); | |
271 | static_assert(test_property<is_nothrow_swappable, | |
272 | ns5::SwapThrow>(false), ""); | |
273 | static_assert(test_property<is_nothrow_swappable, | |
274 | ns5::SwapThrow[1]>(false), ""); | |
275 | static_assert(test_property<is_nothrow_swappable, | |
276 | ns5::SwapThrow[2][3][4]>(false), ""); | |
277 | static_assert(test_property<is_nothrow_swappable, | |
278 | ThrowCopyConsClass>(false), ""); | |
279 | static_assert(test_property<is_nothrow_swappable, | |
280 | std::pair<ThrowCopyConsClass, ThrowCopyConsClass>>(false), ""); | |
281 | static_assert(test_property<is_nothrow_swappable, | |
282 | std::tuple<ThrowCopyConsClass>>(false), ""); | |
283 | static_assert(test_property<is_nothrow_swappable, | |
284 | std::array<ThrowCopyConsClass, 1>>(false), ""); | |
285 | static_assert(test_property<is_nothrow_swappable, | |
286 | std::queue<ThrowCopyConsClass>>(true), ""); | |
287 | static_assert(test_property<is_nothrow_swappable, | |
288 | std::priority_queue<ThrowCopyConsClass>>(true), ""); | |
289 | static_assert(test_property<is_nothrow_swappable, | |
290 | std::stack<ThrowCopyConsClass>>(true), ""); | |
291 | static_assert(test_property<is_nothrow_swappable, | |
292 | std::priority_queue<int, std::vector<int>, | |
293 | comps::CompareNonCopyable>>(false), ""); | |
294 | static_assert(test_property<is_nothrow_swappable, | |
295 | std::priority_queue<int, std::vector<int>, | |
296 | comps::CompareThrowCopyable>>(false), ""); | |
297 | } |