]>
Commit | Line | Data |
---|---|---|
137422c8 VV |
1 | // { dg-options "-std=gnu++17" } |
2 | // { dg-do compile } | |
3 | ||
4 | // Copyright (C) 2014-2016 Free Software Foundation, Inc. | |
5 | // | |
6 | // This file is part of the GNU ISO C++ Library. This library is free | |
7 | // software; you can redistribute it and/or modify it under the | |
8 | // terms of the GNU General Public License as published by the | |
9 | // Free Software Foundation; either version 3, or (at your option) | |
10 | // any later version. | |
11 | ||
12 | // This library is distributed in the hope that it will be useful, | |
13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | // GNU General Public License for more details. | |
16 | ||
c7cbb4da | 17 | // You should have received a copy of the GNU General Public License along |
137422c8 VV |
18 | // with this library; see the file COPYING3. If not see |
19 | // <http://www.gnu.org/licenses/>. | |
20 | ||
21 | #include <type_traits> | |
22 | ||
23 | using namespace std; | |
24 | ||
25 | // These tests are rather simple, the front-end tests already test | |
26 | // variable templates, and the library tests for the underlying | |
27 | // traits are more elaborate. These are just simple sanity tests. | |
28 | ||
29 | static_assert(is_void_v<void> && is_void<void>::value, ""); | |
30 | static_assert(!is_void_v<int> && !is_void<int>::value, ""); | |
31 | ||
32 | static_assert(is_null_pointer_v<nullptr_t> | |
33 | && is_null_pointer<nullptr_t>::value, ""); | |
34 | static_assert(!is_null_pointer_v<void*> | |
35 | && !is_null_pointer<void*>::value, ""); | |
36 | ||
37 | static_assert(is_integral_v<int> && is_integral<int>::value, ""); | |
38 | static_assert(!is_integral_v<int*> && !is_integral<int*>::value, ""); | |
39 | ||
40 | static_assert(is_floating_point_v<float> | |
41 | && is_floating_point<float>::value, ""); | |
42 | static_assert(!is_floating_point_v<int> | |
43 | && !is_floating_point<int>::value, ""); | |
44 | ||
45 | static_assert(is_array_v<char[42]> && is_array<char[42]>::value, ""); | |
46 | static_assert(!is_array_v<char*> && !is_array<char*>::value, ""); | |
47 | ||
48 | static_assert(is_pointer_v<int*> && is_pointer<int*>::value, ""); | |
49 | static_assert(!is_pointer_v<int> && !is_pointer<int>::value, ""); | |
50 | ||
51 | static_assert(is_lvalue_reference_v<int&> | |
52 | && is_lvalue_reference<int&>::value, ""); | |
53 | static_assert(!is_lvalue_reference_v<int> | |
54 | && !is_lvalue_reference<int>::value, ""); | |
55 | ||
56 | static_assert(is_rvalue_reference_v<int&&> | |
57 | && is_rvalue_reference<int&&>::value, ""); | |
58 | static_assert(!is_rvalue_reference_v<int> | |
59 | && !is_rvalue_reference<int>::value, ""); | |
60 | ||
61 | struct EmptyFinal final {}; | |
62 | ||
63 | static_assert(is_member_object_pointer_v<int (EmptyFinal::*)> | |
64 | && is_member_object_pointer<int (EmptyFinal::*)>::value, ""); | |
65 | static_assert(!is_member_object_pointer_v<void*> | |
66 | && !is_member_object_pointer<void*>::value, ""); | |
67 | ||
68 | static_assert(is_member_function_pointer_v<int (EmptyFinal::*)()> | |
69 | && is_member_function_pointer<int (EmptyFinal::*)()>::value, ""); | |
70 | static_assert(!is_member_function_pointer_v<void*> | |
71 | && !is_member_function_pointer<void*>::value, ""); | |
72 | ||
73 | enum Enum {}; | |
74 | ||
75 | static_assert(is_enum_v<Enum> && is_enum<Enum>::value, ""); | |
76 | static_assert(!is_enum_v<int> && !is_enum<int>::value, ""); | |
77 | ||
78 | union Union; | |
79 | ||
80 | static_assert(is_union_v<Union> && is_union<Union>::value, ""); | |
81 | static_assert(!is_union_v<int> && !is_union<int>::value, ""); | |
82 | ||
83 | static_assert(is_class_v<EmptyFinal> && is_class<EmptyFinal>::value, ""); | |
84 | static_assert(!is_class_v<int> && !is_class<int>::value, ""); | |
85 | ||
86 | static_assert(is_function_v<void()> && is_function<void()>::value, ""); | |
87 | static_assert(!is_function_v<void(*)()> && !is_function<void(*)()>::value, ""); | |
88 | ||
89 | static_assert(is_reference_v<int&> && is_reference<int&>::value, ""); | |
90 | static_assert(!is_reference_v<int> && !is_reference<int>::value, ""); | |
91 | ||
92 | static_assert(is_arithmetic_v<int> && is_arithmetic<int>::value, ""); | |
93 | static_assert(!is_arithmetic_v<void*> && !is_arithmetic<void*>::value, ""); | |
94 | ||
95 | static_assert(is_fundamental_v<int> && is_fundamental<int>::value, ""); | |
96 | static_assert(!is_fundamental_v<EmptyFinal> | |
97 | && !is_fundamental<EmptyFinal>::value, ""); | |
98 | ||
99 | static_assert(is_object_v<int> && is_object<int>::value, ""); | |
100 | static_assert(!is_object_v<int&> && !is_object<int&>::value, ""); | |
101 | ||
102 | static_assert(is_scalar_v<int> && is_scalar<int>::value, ""); | |
103 | static_assert(!is_scalar_v<int&> && !is_scalar<int&>::value, ""); | |
104 | ||
105 | static_assert(is_compound_v<EmptyFinal> | |
106 | && is_compound<EmptyFinal>::value, ""); | |
107 | static_assert(!is_compound_v<int> && !is_compound<int>::value, ""); | |
108 | ||
109 | static_assert(is_member_pointer_v<int (EmptyFinal::*)> | |
110 | && is_member_pointer<int (EmptyFinal::*)>::value, ""); | |
111 | static_assert(!is_member_pointer_v<void*> | |
112 | && !is_member_pointer<void*>::value, ""); | |
113 | ||
114 | static_assert(is_const_v<const int> && is_const<const int>::value, ""); | |
115 | static_assert(!is_const_v<int> && !is_const<int>::value, ""); | |
116 | ||
117 | static_assert(is_volatile_v<volatile int> | |
118 | && is_volatile<volatile int>::value, ""); | |
119 | static_assert(!is_volatile_v<int> && !is_volatile<int>::value, ""); | |
120 | ||
121 | struct NType | |
122 | { | |
123 | NType(int); | |
124 | ~NType(); | |
125 | int i; | |
126 | private: | |
127 | NType(const NType&); | |
128 | NType& operator=(const NType&); | |
129 | int i2; | |
130 | }; | |
131 | ||
132 | static_assert(is_trivial_v<int> && is_trivial<int>::value, ""); | |
133 | static_assert(!is_trivial_v<NType> && !is_trivial<NType>::value, ""); | |
134 | ||
135 | static_assert(is_trivially_copyable_v<int> | |
136 | && is_trivially_copyable<int>::value, ""); | |
137 | static_assert(!is_trivially_copyable_v<NType> | |
138 | && !is_trivially_copyable<NType>::value, ""); | |
139 | ||
140 | static_assert(is_standard_layout_v<int> | |
141 | && is_standard_layout<int>::value, ""); | |
142 | static_assert(!is_standard_layout_v<NType> | |
143 | && !is_standard_layout<NType>::value, ""); | |
144 | ||
145 | static_assert(is_pod_v<int> | |
146 | && is_pod<int>::value, ""); | |
147 | static_assert(!is_pod_v<NType> | |
148 | && !is_pod<NType>::value, ""); | |
149 | ||
150 | static_assert(is_literal_type_v<int> | |
151 | && is_literal_type<int>::value, ""); | |
152 | static_assert(!is_literal_type_v<NType> | |
153 | && !is_literal_type<NType>::value, ""); | |
154 | ||
155 | static_assert(is_empty_v<EmptyFinal> | |
156 | && is_empty<EmptyFinal>::value, ""); | |
157 | static_assert(!is_empty_v<NType> | |
158 | && !is_empty<NType>::value, ""); | |
159 | ||
160 | struct Abstract {protected: virtual ~Abstract() = 0;}; | |
161 | struct Poly : Abstract {virtual ~Poly();}; | |
162 | ||
163 | static_assert(is_polymorphic_v<Poly> | |
164 | && is_polymorphic<Poly>::value, ""); | |
165 | static_assert(!is_polymorphic_v<EmptyFinal> | |
166 | && !is_polymorphic<EmptyFinal>::value, ""); | |
167 | ||
168 | ||
169 | ||
170 | static_assert(is_abstract_v<Abstract> | |
171 | && is_abstract<Abstract>::value, ""); | |
172 | static_assert(!is_abstract_v<EmptyFinal> | |
173 | && !is_abstract<EmptyFinal>::value, ""); | |
174 | ||
175 | static_assert(is_final_v<EmptyFinal> | |
176 | && is_final<EmptyFinal>::value, ""); | |
177 | static_assert(!is_final_v<Abstract> | |
178 | && !is_final<Abstract>::value, ""); | |
179 | ||
180 | static_assert(is_signed_v<int> && is_signed<int>::value, ""); | |
181 | static_assert(!is_signed_v<unsigned int> | |
182 | && !is_signed<unsigned int>::value, ""); | |
183 | ||
184 | static_assert(is_constructible_v<int, int> | |
185 | && is_constructible<int, int>::value, ""); | |
186 | static_assert(!is_constructible_v<int, void*> | |
187 | && !is_constructible<int, void*>::value, ""); | |
188 | ||
189 | static_assert(is_default_constructible_v<int> | |
190 | && is_default_constructible<int>::value, ""); | |
191 | static_assert(!is_default_constructible_v<NType> | |
192 | && !is_default_constructible<NType>::value, ""); | |
193 | ||
194 | static_assert(is_copy_constructible_v<int> | |
195 | && is_copy_constructible<int>::value, ""); | |
196 | static_assert(!is_copy_constructible_v<NType> | |
197 | && !is_copy_constructible<NType>::value, ""); | |
198 | ||
199 | static_assert(is_move_constructible_v<int> | |
200 | && is_copy_constructible<int>::value, ""); | |
201 | static_assert(!is_move_constructible_v<NType> | |
202 | && !is_copy_constructible<NType>::value, ""); | |
203 | ||
204 | static_assert(is_assignable_v<int&, int> | |
205 | && is_assignable<int&, int>::value, ""); | |
206 | static_assert(!is_assignable_v<int, int> | |
207 | && !is_assignable<int, int>::value, ""); | |
208 | ||
209 | static_assert(is_copy_assignable_v<int> | |
210 | && is_copy_assignable<int>::value, ""); | |
211 | static_assert(!is_copy_assignable_v<NType> | |
212 | && !is_copy_assignable<NType>::value, ""); | |
213 | ||
214 | static_assert(is_move_assignable_v<int> | |
215 | && is_move_assignable<int>::value, ""); | |
216 | static_assert(!is_move_assignable_v<NType> | |
217 | && !is_move_assignable<NType>::value, ""); | |
218 | ||
219 | static_assert(is_destructible_v<int> | |
220 | && is_destructible<int>::value, ""); | |
221 | static_assert(!is_destructible_v<Abstract> | |
222 | && !is_destructible<Abstract>::value, ""); | |
223 | ||
224 | static_assert(is_trivially_constructible_v<int, int> | |
225 | && is_trivially_constructible<int, int>::value, ""); | |
226 | static_assert(!is_trivially_constructible_v<NType, NType> | |
227 | && !is_trivially_constructible<NType, NType>::value, ""); | |
228 | ||
229 | static_assert(is_trivially_default_constructible_v<int> | |
230 | && is_trivially_default_constructible<int>::value, ""); | |
231 | static_assert(!is_trivially_default_constructible_v<NType> | |
232 | && !is_trivially_default_constructible<NType>::value, ""); | |
233 | ||
234 | static_assert(is_trivially_copy_constructible_v<int> | |
235 | && is_trivially_copy_constructible<int>::value, ""); | |
236 | static_assert(!is_trivially_copy_constructible_v<NType> | |
237 | && !is_trivially_copy_constructible<NType>::value, ""); | |
238 | ||
239 | static_assert(is_trivially_move_constructible_v<int> | |
240 | && is_trivially_move_constructible<int>::value, ""); | |
241 | static_assert(!is_trivially_move_constructible_v<NType> | |
242 | && !is_trivially_move_constructible<NType>::value, ""); | |
243 | ||
244 | static_assert(is_trivially_assignable_v<int&, int> | |
245 | && is_trivially_assignable<int&, int>::value, ""); | |
246 | static_assert(!is_trivially_assignable_v<NType, NType> | |
247 | && !is_trivially_assignable<NType, NType>::value, ""); | |
248 | ||
249 | static_assert(is_trivially_copy_assignable_v<int> | |
250 | && is_trivially_copy_assignable<int>::value, ""); | |
251 | static_assert(!is_trivially_copy_assignable_v<NType> | |
252 | && !is_trivially_copy_assignable<NType>::value, ""); | |
253 | ||
254 | static_assert(is_trivially_move_assignable_v<int> | |
255 | && is_trivially_move_assignable<int>::value, ""); | |
256 | static_assert(!is_trivially_move_assignable_v<NType> | |
257 | && !is_trivially_move_assignable<NType>::value, ""); | |
258 | ||
259 | static_assert(is_trivially_destructible_v<int> | |
260 | && is_trivially_destructible<int>::value, ""); | |
261 | static_assert(!is_trivially_destructible_v<Abstract> | |
262 | && !is_trivially_destructible<Abstract>::value, ""); | |
263 | ||
264 | static_assert(is_nothrow_constructible_v<int, int> | |
265 | && is_nothrow_constructible<int, int>::value, ""); | |
266 | static_assert(!is_nothrow_constructible_v<NType, NType> | |
267 | && !is_nothrow_constructible<NType, NType>::value, ""); | |
268 | ||
269 | static_assert(is_nothrow_default_constructible_v<int> | |
270 | && is_nothrow_default_constructible<int>::value, ""); | |
271 | static_assert(!is_nothrow_default_constructible_v<NType> | |
272 | && !is_nothrow_default_constructible<NType>::value, ""); | |
273 | ||
274 | static_assert(is_nothrow_copy_constructible_v<int> | |
275 | && is_nothrow_copy_constructible<int>::value, ""); | |
276 | static_assert(!is_nothrow_copy_constructible_v<NType> | |
277 | && !is_nothrow_copy_constructible<NType>::value, ""); | |
278 | ||
279 | static_assert(is_nothrow_move_constructible_v<int> | |
280 | && is_nothrow_move_constructible<int>::value, ""); | |
281 | static_assert(!is_nothrow_move_constructible_v<NType> | |
282 | && !is_nothrow_move_constructible<NType>::value, ""); | |
283 | ||
284 | static_assert(is_nothrow_assignable_v<int&, int> | |
285 | && is_nothrow_assignable<int&, int>::value, ""); | |
286 | static_assert(!is_nothrow_assignable_v<NType, NType> | |
287 | && !is_nothrow_assignable<NType, NType>::value, ""); | |
288 | ||
289 | static_assert(is_nothrow_copy_assignable_v<int> | |
290 | && is_nothrow_copy_assignable<int>::value, ""); | |
291 | static_assert(!is_nothrow_copy_assignable_v<NType> | |
292 | && !is_nothrow_copy_assignable<NType>::value, ""); | |
293 | ||
294 | static_assert(is_nothrow_move_assignable_v<int> | |
295 | && is_nothrow_move_assignable<int>::value, ""); | |
296 | static_assert(!is_nothrow_move_assignable_v<NType> | |
297 | && !is_nothrow_move_assignable<NType>::value, ""); | |
298 | ||
299 | static_assert(has_virtual_destructor_v<Abstract> | |
300 | && has_virtual_destructor<Abstract>::value, ""); | |
301 | static_assert(!has_virtual_destructor_v<NType> | |
302 | && !has_virtual_destructor<NType>::value, ""); | |
303 | ||
304 | static_assert(alignment_of_v<int> == alignof(int) | |
305 | && alignment_of<int>::value == alignof(int) , ""); | |
306 | ||
307 | static_assert(rank_v<int[1][1]> == rank<int[1][1]>::value, ""); | |
308 | ||
309 | static_assert(extent_v<int[1][2], 1> == 2 | |
310 | && extent<int[1][2], 1>::value == 2, ""); | |
311 | ||
312 | static_assert(is_same_v<int, int> && is_same<int, int>::value, ""); | |
313 | static_assert(!is_same_v<int, char> && !is_same<int, char>::value, ""); | |
314 | ||
315 | static_assert(is_base_of_v<Abstract, Poly> | |
316 | && is_base_of<Abstract, Poly>::value, ""); | |
317 | static_assert(!is_base_of_v<Abstract, NType> | |
318 | && !is_base_of<Abstract, NType>::value, ""); | |
319 | ||
320 | static_assert(is_convertible_v<int&, const int&> | |
321 | && is_convertible<int&, const int&>::value, ""); | |
322 | static_assert(!is_convertible_v<const int&, int&> | |
323 | && !is_convertible<const int&, int&>::value, ""); | |
324 | ||
325 | static_assert(negation_v<false_type>, ""); | |
326 | static_assert(!negation_v<true_type>, ""); | |
327 | static_assert(conjunction_v<>, ""); | |
328 | static_assert(!disjunction_v<>, ""); | |
329 | static_assert(conjunction_v<true_type>, ""); | |
330 | static_assert(!conjunction_v<false_type>, ""); | |
331 | static_assert(disjunction_v<true_type>, ""); | |
332 | static_assert(!disjunction_v<false_type>, ""); | |
333 | static_assert(conjunction_v<true_type, true_type>, ""); | |
334 | static_assert(!conjunction_v<true_type, false_type>, ""); | |
335 | static_assert(disjunction_v<false_type, true_type>, ""); | |
336 | static_assert(!disjunction_v<false_type, false_type>, ""); | |
337 | static_assert(conjunction_v<true_type, true_type, | |
338 | true_type>, ""); | |
339 | static_assert(!conjunction_v<true_type, true_type, | |
340 | false_type>, ""); | |
341 | static_assert(disjunction_v<false_type, false_type, | |
342 | true_type>, ""); | |
343 | static_assert(!disjunction_v<false_type, false_type, | |
344 | false_type>, ""); |