1 // { dg-options "-std=gnu++17" }
4 // Copyright (C) 2014-2016 Free Software Foundation, Inc.
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)
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.
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING3. If not see
19 // <http://www.gnu.org/licenses/>.
21 #include <type_traits>
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.
29 static_assert(is_void_v
<void> && is_void
<void>::value
, "");
30 static_assert(!is_void_v
<int> && !is_void
<int>::value
, "");
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
, "");
37 static_assert(is_integral_v
<int> && is_integral
<int>::value
, "");
38 static_assert(!is_integral_v
<int*> && !is_integral
<int*>::value
, "");
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
, "");
45 static_assert(is_array_v
<char[42]> && is_array
<char[42]>::value
, "");
46 static_assert(!is_array_v
<char*> && !is_array
<char*>::value
, "");
48 static_assert(is_pointer_v
<int*> && is_pointer
<int*>::value
, "");
49 static_assert(!is_pointer_v
<int> && !is_pointer
<int>::value
, "");
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
, "");
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
, "");
61 struct EmptyFinal final
{};
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
, "");
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
, "");
75 static_assert(is_enum_v
<Enum
> && is_enum
<Enum
>::value
, "");
76 static_assert(!is_enum_v
<int> && !is_enum
<int>::value
, "");
80 static_assert(is_union_v
<Union
> && is_union
<Union
>::value
, "");
81 static_assert(!is_union_v
<int> && !is_union
<int>::value
, "");
83 static_assert(is_class_v
<EmptyFinal
> && is_class
<EmptyFinal
>::value
, "");
84 static_assert(!is_class_v
<int> && !is_class
<int>::value
, "");
86 static_assert(is_function_v
<void()> && is_function
<void()>::value
, "");
87 static_assert(!is_function_v
<void(*)()> && !is_function
<void(*)()>::value
, "");
89 static_assert(is_reference_v
<int&> && is_reference
<int&>::value
, "");
90 static_assert(!is_reference_v
<int> && !is_reference
<int>::value
, "");
92 static_assert(is_arithmetic_v
<int> && is_arithmetic
<int>::value
, "");
93 static_assert(!is_arithmetic_v
<void*> && !is_arithmetic
<void*>::value
, "");
95 static_assert(is_fundamental_v
<int> && is_fundamental
<int>::value
, "");
96 static_assert(!is_fundamental_v
<EmptyFinal
>
97 && !is_fundamental
<EmptyFinal
>::value
, "");
99 static_assert(is_object_v
<int> && is_object
<int>::value
, "");
100 static_assert(!is_object_v
<int&> && !is_object
<int&>::value
, "");
102 static_assert(is_scalar_v
<int> && is_scalar
<int>::value
, "");
103 static_assert(!is_scalar_v
<int&> && !is_scalar
<int&>::value
, "");
105 static_assert(is_compound_v
<EmptyFinal
>
106 && is_compound
<EmptyFinal
>::value
, "");
107 static_assert(!is_compound_v
<int> && !is_compound
<int>::value
, "");
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
, "");
114 static_assert(is_const_v
<const int> && is_const
<const int>::value
, "");
115 static_assert(!is_const_v
<int> && !is_const
<int>::value
, "");
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
, "");
128 NType
& operator=(const NType
&);
132 static_assert(is_trivial_v
<int> && is_trivial
<int>::value
, "");
133 static_assert(!is_trivial_v
<NType
> && !is_trivial
<NType
>::value
, "");
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
, "");
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
, "");
145 static_assert(is_pod_v
<int>
146 && is_pod
<int>::value
, "");
147 static_assert(!is_pod_v
<NType
>
148 && !is_pod
<NType
>::value
, "");
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
, "");
155 static_assert(is_empty_v
<EmptyFinal
>
156 && is_empty
<EmptyFinal
>::value
, "");
157 static_assert(!is_empty_v
<NType
>
158 && !is_empty
<NType
>::value
, "");
160 struct Abstract
{protected: virtual ~Abstract() = 0;};
161 struct Poly
: Abstract
{virtual ~Poly();};
163 static_assert(is_polymorphic_v
<Poly
>
164 && is_polymorphic
<Poly
>::value
, "");
165 static_assert(!is_polymorphic_v
<EmptyFinal
>
166 && !is_polymorphic
<EmptyFinal
>::value
, "");
170 static_assert(is_abstract_v
<Abstract
>
171 && is_abstract
<Abstract
>::value
, "");
172 static_assert(!is_abstract_v
<EmptyFinal
>
173 && !is_abstract
<EmptyFinal
>::value
, "");
175 static_assert(is_final_v
<EmptyFinal
>
176 && is_final
<EmptyFinal
>::value
, "");
177 static_assert(!is_final_v
<Abstract
>
178 && !is_final
<Abstract
>::value
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
219 static_assert(is_destructible_v
<int>
220 && is_destructible
<int>::value
, "");
221 static_assert(!is_destructible_v
<Abstract
>
222 && !is_destructible
<Abstract
>::value
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
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
, "");
304 static_assert(alignment_of_v
<int> == alignof(int)
305 && alignment_of
<int>::value
== alignof(int) , "");
307 static_assert(rank_v
<int[1][1]> == rank
<int[1][1]>::value
, "");
309 static_assert(extent_v
<int[1][2], 1> == 2
310 && extent
<int[1][2], 1>::value
== 2, "");
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
, "");
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
, "");
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
, "");
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
,
339 static_assert(!conjunction_v
<true_type
, true_type
,
341 static_assert(disjunction_v
<false_type
, false_type
,
343 static_assert(!disjunction_v
<false_type
, false_type
,