utest/fbl/type_support_tests.cpp

5 #include <fbl/type_support.h>
13 static_assert(fbl::is_void<void>::value, "");
14 static_assert(fbl::is_void<const void>::value, "");
15 static_assert(fbl::is_void<volatile void>::value, "");
16 static_assert(fbl::is_void<const volatile void>::value, "");
18 static_assert(!fbl::is_void<int>::value, "");
19 static_assert(!fbl::is_void<void*>::value, "");
22 static_assert(fbl::is_null_pointer<decltype(nullptr)>::value, "");
23 static_assert(fbl::is_null_pointer<const decltype(nullptr)>::value, "");
24 static_assert(fbl::is_null_pointer<volatile decltype(nullptr)>::value, "");
25 static_assert(fbl::is_null_pointer<const volatile decltype(nullptr)>::value, "");
27 static_assert(!fbl::is_null_pointer<int>::value, "");
28 static_assert(!fbl::is_null_pointer<int*>::value, "");
29 static_assert(!fbl::is_null_pointer<s*>::value, "");
30 static_assert(!fbl::is_null_pointer<fp>::value, "");
33 static_assert(fbl::is_pointer<int*>::value, "");
34 static_assert(fbl::is_pointer<float*>::value, "");
35 static_assert(fbl::is_pointer<s*>::value, "");
36 static_assert(fbl::is_pointer<u*>::value, "");
37 static_assert(fbl::is_pointer<s*>::value, "");
38 static_assert(fbl::is_pointer<fp*>::value, "");
40 static_assert(fbl::is_pointer<const int*>::value, "");
41 static_assert(fbl::is_pointer<const float*>::value, "");
42 static_assert(fbl::is_pointer<const s*>::value, "");
43 static_assert(fbl::is_pointer<const u*>::value, "");
44 static_assert(fbl::is_pointer<const s*>::value, "");
46 static_assert(fbl::is_pointer<volatile int*>::value, "");
47 static_assert(fbl::is_pointer<volatile float*>::value, "");
48 static_assert(fbl::is_pointer<volatile s*>::value, "");
49 static_assert(fbl::is_pointer<volatile u*>::value, "");
50 static_assert(fbl::is_pointer<volatile s*>::value, "");
52 static_assert(fbl::is_pointer<const volatile int*>::value, "");
53 static_assert(fbl::is_pointer<const volatile float*>::value, "");
54 static_assert(fbl::is_pointer<const volatile s*>::value, "");
55 static_assert(fbl::is_pointer<const volatile u*>::value, "");
56 static_assert(fbl::is_pointer<const volatile s*>::value, "");
58 static_assert(!fbl::is_pointer<int>::value, "");
59 static_assert(!fbl::is_pointer<float>::value, "");
60 static_assert(!fbl::is_pointer<s>::value, "");
61 static_assert(!fbl::is_pointer<u>::value, "");
62 static_assert(!fbl::is_pointer<s>::value, "");
63 static_assert(!fbl::is_pointer<fp>::value, "");
65 static_assert(!fbl::is_pointer<const int>::value, "");
66 static_assert(!fbl::is_pointer<const float>::value, "");
67 static_assert(!fbl::is_pointer<const s>::value, "");
68 static_assert(!fbl::is_pointer<const u>::value, "");
69 static_assert(!fbl::is_pointer<const s>::value, "");
71 static_assert(!fbl::is_pointer<volatile int>::value, "");
72 static_assert(!fbl::is_pointer<volatile float>::value, "");
73 static_assert(!fbl::is_pointer<volatile s>::value, "");
74 static_assert(!fbl::is_pointer<volatile u>::value, "");
75 static_assert(!fbl::is_pointer<volatile s>::value, "");
77 static_assert(!fbl::is_pointer<const volatile int>::value, "");
78 static_assert(!fbl::is_pointer<const volatile float>::value, "");
79 static_assert(!fbl::is_pointer<const volatile s>::value, "");
80 static_assert(!fbl::is_pointer<const volatile u>::value, "");
81 static_assert(!fbl::is_pointer<const volatile s>::value, "");
84 static_assert(fbl::is_reference<int&>::value, "");
85 static_assert(fbl::is_reference<int&&>::value, "");
86 static_assert(fbl::is_reference<float&>::value, "");
87 static_assert(fbl::is_reference<float&&>::value, "");
88 static_assert(fbl::is_reference<s&>::value, "");
89 static_assert(fbl::is_reference<s&&>::value, "");
90 static_assert(fbl::is_reference<u&>::value, "");
91 static_assert(fbl::is_reference<u&&>::value, "");
92 static_assert(fbl::is_reference<s&>::value, "");
93 static_assert(fbl::is_reference<s&&>::value, "");
94 static_assert(fbl::is_reference<fp&>::value, "");
95 static_assert(fbl::is_reference<fp&&>::value, "");
97 static_assert(fbl::is_reference<const int&>::value, "");
98 static_assert(fbl::is_reference<const int&&>::value, "");
99 static_assert(fbl::is_reference<const float&>::value, "");
100 static_assert(fbl::is_reference<const float&&>::value, "");
101 static_assert(fbl::is_reference<const s&>::value, "");
102 static_assert(fbl::is_reference<const s&&>::value, "");
103 static_assert(fbl::is_reference<const u&>::value, "");
104 static_assert(fbl::is_reference<const u&&>::value, "");
105 static_assert(fbl::is_reference<const s&>::value, "");
106 static_assert(fbl::is_reference<const s&&>::value, "");
108 static_assert(fbl::is_reference<volatile int&>::value, "");
109 static_assert(fbl::is_reference<volatile int&&>::value, "");
110 static_assert(fbl::is_reference<volatile float&>::value, "");
111 static_assert(fbl::is_reference<volatile float&&>::value, "");
112 static_assert(fbl::is_reference<volatile s&>::value, "");
113 static_assert(fbl::is_reference<volatile s&&>::value, "");
114 static_assert(fbl::is_reference<volatile u&>::value, "");
115 static_assert(fbl::is_reference<volatile u&&>::value, "");
116 static_assert(fbl::is_reference<volatile s&>::value, "");
117 static_assert(fbl::is_reference<volatile s&&>::value, "");
119 static_assert(fbl::is_reference<const volatile int&>::value, "");
120 static_assert(fbl::is_reference<const volatile int&&>::value, "");
121 static_assert(fbl::is_reference<const volatile float&>::value, "");
122 static_assert(fbl::is_reference<const volatile float&&>::value, "");
123 static_assert(fbl::is_reference<const volatile s&>::value, "");
124 static_assert(fbl::is_reference<const volatile s&&>::value, "");
125 static_assert(fbl::is_reference<const volatile u&>::value, "");
126 static_assert(fbl::is_reference<const volatile u&&>::value, "");
127 static_assert(fbl::is_reference<const volatile s&>::value, "");
128 static_assert(fbl::is_reference<const volatile s&&>::value, "");
130 static_assert(!fbl::is_reference<int>::value, "");
131 static_assert(!fbl::is_reference<float>::value, "");
132 static_assert(!fbl::is_reference<s>::value, "");
133 static_assert(!fbl::is_reference<u>::value, "");
134 static_assert(!fbl::is_reference<s>::value, "");
135 static_assert(!fbl::is_reference<fp>::value, "");
137 static_assert(!fbl::is_reference<const int>::value, "");
138 static_assert(!fbl::is_reference<const float>::value, "");
139 static_assert(!fbl::is_reference<const s>::value, "");
140 static_assert(!fbl::is_reference<const u>::value, "");
141 static_assert(!fbl::is_reference<const s>::value, "");
143 static_assert(!fbl::is_reference<volatile int>::value, "");
144 static_assert(!fbl::is_reference<volatile float>::value, "");
145 static_assert(!fbl::is_reference<volatile s>::value, "");
146 static_assert(!fbl::is_reference<volatile u>::value, "");
147 static_assert(!fbl::is_reference<volatile s>::value, "");
149 static_assert(!fbl::is_reference<const volatile int>::value, "");
150 static_assert(!fbl::is_reference<const volatile float>::value, "");
151 static_assert(!fbl::is_reference<const volatile s>::value, "");
152 static_assert(!fbl::is_reference<const volatile u>::value, "");
153 static_assert(!fbl::is_reference<const volatile s>::value, "");
156 static_assert(fbl::is_union<u>::value, "");
158 static_assert(!fbl::is_union<u*>::value, "");
159 static_assert(!fbl::is_union<u&>::value, "");
160 static_assert(!fbl::is_union<u&&>::value, "");
162 static_assert(!fbl::is_union<int>::value, "");
163 static_assert(!fbl::is_union<float>::value, "");
164 static_assert(!fbl::is_union<s>::value, "");
165 static_assert(!fbl::is_union<s>::value, "");
166 static_assert(!fbl::is_union<fp>::value, "");
169 static_assert(!fbl::is_const<int>::value, "");
170 static_assert(fbl::is_const<const int>::value, "");
171 static_assert(!fbl::is_const<s>::value, "");
172 static_assert(fbl::is_const<const s>::value, "");
173 static_assert(!fbl::is_const<u>::value, "");
174 static_assert(fbl::is_const<const u>::value, "");
176 static_assert(!fbl::is_const<int*>::value, "");
177 static_assert(fbl::is_const<int* const>::value, "");
178 static_assert(!fbl::is_const<const int*>::value, "");
179 static_assert(fbl::is_const<const int* const>::value, "");
185 static_assert(fbl::is_same<fbl::underlying_type<int_enum>::type, int>::value, "expected int");
186 static_assert(fbl::is_same<fbl::underlying_type<char_enum>::type, char>::value, "expected char");
189 static_assert(fbl::is_same<fbl::match_cv<int, void>::type, void>::value, "wrong type");
190 static_assert(fbl::is_same<fbl::match_cv<const int, void>::type, const void>::value,
192 static_assert(fbl::is_same<fbl::match_cv<volatile void, char>::type, volatile char>::value,
194 static_assert(fbl::is_same<fbl::match_cv<const int, const char>::type, const char>::value,
196 static_assert(fbl::is_same<fbl::match_cv<const int, volatile char>::type, const char>::value,
198 static_assert(fbl::is_same<fbl::match_cv<char, const volatile void>::type, void>::value,
204 static_assert(!fbl::is_class<int>::value, "'int' should not pass the is_class<> test!");
207 static_assert(fbl::is_class<A>::value, "'class' should pass the is_class<> test!");
210 static_assert(fbl::is_class<B>::value, "'struct' should pass the is_class<> test!");
213 static_assert(!fbl::is_class<C>::value, "'union' should not pass the is_class<> test!");
216 static_assert(!fbl::is_class<D>::value, "'enum' should not pass the is_class<> test!");
219 static_assert(!fbl::is_class<E>::value, "'enum class' should not pass the is_class<> test!");
225 static_assert(!fbl::is_base_of<int, int>::value,
229 static_assert(fbl::is_base_of<A, A>::value, "A should be a base of A!");
232 static_assert( fbl::is_base_of<B, B>::value, "B should be a base of B!");
233 static_assert( fbl::is_base_of<A, B>::value, "A should be a base of B!");
234 static_assert(!fbl::is_base_of<B, A>::value, "B should not be a base of A!");
237 static_assert( fbl::is_base_of<C, C>::value, "C should be a base of C!");
238 static_assert( fbl::is_base_of<B, C>::value, "B should be a base of C!");
239 static_assert( fbl::is_base_of<A, C>::value, "A should be a base of C!");
240 static_assert(!fbl::is_base_of<C, B>::value, "C should not be a base of B!");
241 static_assert(!fbl::is_base_of<C, A>::value, "C should not be a base of A!");
245 static_assert( fbl::is_base_of<D, D>::value, "D should be a base of D!");
246 static_assert( fbl::is_base_of<E, E>::value, "E should be a base of E!");
247 static_assert( fbl::is_base_of<A, E>::value, "A should be a base of E!");
248 static_assert( fbl::is_base_of<B, E>::value, "B should be a base of E!");
249 static_assert(!fbl::is_base_of<C, E>::value, "C should not be a base of E!");
250 static_assert( fbl::is_base_of<D, E>::value, "D should be a base of E!");
251 static_assert(!fbl::is_base_of<E, A>::value, "E should not be a base of A!");
252 static_assert(!fbl::is_base_of<E, B>::value, "E should not be a base of B!");
253 static_assert(!fbl::is_base_of<E, C>::value, "E should not be a base of C!");
254 static_assert(!fbl::is_base_of<E, D>::value, "E should not be a base of D!");
257 static_assert(fbl::is_base_of<sA, sA>::value, "sA should be a base of sA!");
260 static_assert( fbl::is_base_of<sB, sB>::value, "sB should be a base of sB!");
261 static_assert( fbl::is_base_of<sA, sB>::value, "sA should be a base of sB!");
262 static_assert(!fbl::is_base_of<sB, sA>::value, "sB should not be a base of sA!");
265 static_assert( fbl::is_base_of<sC, sC>::value, "sC should be a base of sC!");
266 static_assert( fbl::is_base_of<sB, sC>::value, "sB should be a base of sC!");
267 static_assert( fbl::is_base_of<sA, sC>::value, "sA should be a base of sC!");
268 static_assert(!fbl::is_base_of<sC, sB>::value, "sC should not be a base of sB!");
269 static_assert(!fbl::is_base_of<sC, sA>::value, "sC should not be a base of sA!");
273 static_assert( fbl::is_base_of<sD, sD>::value, "sD should be a base of sD!");
274 static_assert( fbl::is_base_of<sE, sE>::value, "sE should be a base of sE!");
275 static_assert( fbl::is_base_of<sA, sE>::value, "sA should be a base of sE!");
276 static_assert( fbl::is_base_of<sB, sE>::value, "sB should be a base of sE!");
277 static_assert(!fbl::is_base_of<sC, sE>::value, "sC should not be a base of sE!");
278 static_assert( fbl::is_base_of<sD, sE>::value, "sD should be a base of sE!");
279 static_assert(!fbl::is_base_of<sE, sA>::value, "sE should not be a base of sA!");
280 static_assert(!fbl::is_base_of<sE, sB>::value, "sE should not be a base of sB!");
281 static_assert(!fbl::is_base_of<sE, sC>::value, "sE should not be a base of sC!");
282 static_assert(!fbl::is_base_of<sE, sD>::value, "sE should not be a base of sD!");
294 static_assert(!fbl::has_virtual_destructor<A>::value, "A should have no virtual destructor");
295 static_assert( fbl::has_virtual_destructor<B>::value, "B should have a virtual destructor");
296 static_assert(!fbl::has_virtual_destructor<C>::value, "C should have no virtual destructor");
297 static_assert( fbl::has_virtual_destructor<D>::value, "D should have a virtual destructor");
298 static_assert( fbl::has_virtual_destructor<E>::value, "E should have a virtual destructor");
304 static_assert(fbl::is_floating_point<float>::value, "float is floating point");
305 static_assert(fbl::is_floating_point<double>::value, "double is floating point");
306 static_assert(fbl::is_floating_point<long double>::value, "long double is floating point");
308 static_assert(!fbl::is_floating_point<int>::value, "int is not floating point");
309 static_assert(!fbl::is_floating_point<decltype(nullptr)>::value, "nullptr is not floating point");
312 static_assert(!fbl::is_floating_point<A>::value, "A is not floating point");
313 static_assert(!fbl::is_floating_point<A*>::value, "A pointer is not floating point");
319 static_assert(fbl::is_integral<bool>::value, "bool is integral");
320 static_assert(fbl::is_integral<char>::value, "char is integral");
321 static_assert(fbl::is_integral<char16_t>::value, "char16_t is integral");
322 static_assert(fbl::is_integral<char32_t>::value, "char32_t is integral");
323 static_assert(fbl::is_integral<wchar_t>::value, "wchar_t is integral");
324 static_assert(fbl::is_integral<signed char>::value, "signed char is integral");
325 static_assert(fbl::is_integral<unsigned char>::value, "unsigned char is integral");
326 static_assert(fbl::is_integral<short int>::value, "short int is integral");
327 static_assert(fbl::is_integral<unsigned short int>::value, "unsigned short int is integral");
328 static_assert(fbl::is_integral<int>::value, "int is integral");
329 static_assert(fbl::is_integral<unsigned int>::value, "unsigned int is integral");
330 static_assert(fbl::is_integral<long int>::value, "long int is integral");
331 static_assert(fbl::is_integral<unsigned long int>::value, "unsigned long int is integral");
332 static_assert(fbl::is_integral<long long int>::value, "long long int is integral");
333 static_assert(fbl::is_integral<unsigned long long int>::value, "unsigned long long int is integral");
335 static_assert(!fbl::is_integral<float>::value, "float is not integral");
336 static_assert(!fbl::is_integral<decltype(nullptr)>::value, "nullptr is not integral");
339 static_assert(!fbl::is_integral<A>::value, "A is not floating point");
340 static_assert(!fbl::is_integral<A*>::value, "A pointer is not integral");
346 static_assert(fbl::is_arithmetic<bool>::value, "bool is arithmetic");
347 static_assert(fbl::is_arithmetic<char>::value, "char is arithmetic");
348 static_assert(fbl::is_arithmetic<char16_t>::value, "char16_t is arithmetic");
349 static_assert(fbl::is_arithmetic<char32_t>::value, "char32_t is arithmetic");
350 static_assert(fbl::is_arithmetic<wchar_t>::value, "wchar_t is arithmetic");
351 static_assert(fbl::is_arithmetic<signed char>::value, "signed char is arithmetic");
352 static_assert(fbl::is_arithmetic<unsigned char>::value, "unsigned char is arithmetic");
353 static_assert(fbl::is_arithmetic<short int>::value, "short int is arithmetic");
354 static_assert(fbl::is_arithmetic<unsigned short int>::value, "unsigned short int is arithmetic");
355 static_assert(fbl::is_arithmetic<int>::value, "int is arithmetic");
356 static_assert(fbl::is_arithmetic<unsigned int>::value, "unsigned int is arithmetic");
357 static_assert(fbl::is_arithmetic<long int>::value, "long int is arithmetic");
358 static_assert(fbl::is_arithmetic<unsigned long int>::value, "unsigned long int is arithmetic");
359 static_assert(fbl::is_arithmetic<long long int>::value, "long long int is arithmetic");
360 static_assert(fbl::is_arithmetic<unsigned long long int>::value, "unsigned long long int is arithmetic");
362 static_assert(fbl::is_arithmetic<float>::value, "float is arithmetic");
363 static_assert(fbl::is_arithmetic<double>::value, "double is arithmetic");
364 static_assert(fbl::is_arithmetic<long double>::value, "long double is arithmetic");
366 static_assert(!fbl::is_arithmetic<decltype(nullptr)>::value, "nullptr is not arithmetic");
369 static_assert(!fbl::is_arithmetic<A>::value, "A is not arithmetic");
370 static_assert(!fbl::is_arithmetic<A*>::value, "A pointer is not arithmetic");
376 static_assert(fbl::is_signed<int>::value, "int is signed");
377 static_assert(!fbl::is_signed<unsigned int>::value, "unsigned int is not signed");
378 static_assert(fbl::is_signed<float>::value, "float is signed");
380 static_assert(!fbl::is_signed<decltype(nullptr)>::value, "nullptr is not signed");
383 static_assert(!fbl::is_signed<A>::value, "A is not signed");
384 static_assert(!fbl::is_signed<A*>::value, "A pointer is not signed");
390 static_assert(!fbl::is_unsigned<int>::value, "int is not unsigned");
391 static_assert(fbl::is_unsigned<unsigned int>::value, "unsigned int is unsigned");
392 static_assert(!fbl::is_unsigned<float>::value, "float is not unsigned");
394 static_assert(!fbl::is_unsigned<decltype(nullptr)>::value, "nullptr is not unsigned");
397 static_assert(!fbl::is_unsigned<A>::value, "A is not unsigned");
398 static_assert(!fbl::is_unsigned<A*>::value, "A pointer is not unsigned");
404 static_assert(fbl::is_signed_integer<int>::value, "int is signed integer");
405 static_assert(!fbl::is_signed_integer<unsigned int>::value, "unsigned int is not signed integer");
406 static_assert(!fbl::is_signed_integer<float>::value, "float is not signed integer");
408 static_assert(!fbl::is_signed_integer<decltype(nullptr)>::value, "nullptr is not signed integer");
411 static_assert(!fbl::is_signed_integer<A>::value, "A is not signed integer");
412 static_assert(!fbl::is_signed_integer<A*>::value, "A pointer is not signed integer");
418 static_assert(!fbl::is_unsigned_integer<int>::value, "int is not unsigned integer");
419 static_assert(fbl::is_unsigned_integer<unsigned int>::value, "unsigned int is unsigned integer");
420 static_assert(!fbl::is_unsigned_integer<float>::value, "float is not unsigned integer");
422 static_assert(!fbl::is_unsigned_integer<decltype(nullptr)>::value, "nullptr is not unsigned integer");
425 static_assert(!fbl::is_unsigned_integer<A>::value, "A is not unsigned integer");
426 static_assert(!fbl::is_unsigned_integer<A*>::value, "A pointer is not unsigned integer");
434 static_assert(fbl::is_enum<E>::value, "enum is an enum");
435 static_assert(!fbl::is_enum<S>::value, "struct is not an enum");
436 static_assert(!fbl::is_enum<int>::value, "int is not an enum");
437 static_assert(!fbl::is_enum<void>::value, "void is not an enum");
461 static_assert(!fbl::is_pointer<StructType>::value,         "StructType is not a pointer!");
462 static_assert( fbl::is_pointer<StructType*>::value,        "StructType* is a pointer!");
463 static_assert( fbl::is_pointer<StructType**>::value,       "StructType** is a pointer!");
464 static_assert(!fbl::is_pointer<ClassType>::value,          "ClassType is not a pointer!");
465 static_assert( fbl::is_pointer<ClassType*>::value,         "ClassType* is a pointer!");
466 static_assert( fbl::is_pointer<ClassType**>::value,        "ClassType** is a pointer!");
467 static_assert(!fbl::is_pointer<EnumType>::value,           "EnumType is not a pointer!");
468 static_assert( fbl::is_pointer<EnumType*>::value,          "EnumType* is a pointer!");
469 static_assert( fbl::is_pointer<EnumType**>::value,         "EnumType** is a pointer!");
470 static_assert(!fbl::is_pointer<UnionType>::value,          "UnionType is not a pointer!");
471 static_assert( fbl::is_pointer<UnionType*>::value,         "UnionType* is a pointer!");
472 static_assert( fbl::is_pointer<UnionType**>::value,        "UnionType** is a pointer!");
473 static_assert(!fbl::is_pointer<int>::value,                "int is not a pointer!");
474 static_assert(!fbl::is_pointer<int[]>::value,              "int[] is not a pointer!");
475 static_assert( fbl::is_pointer<int*>::value,               "int* is a pointer!");
476 static_assert( fbl::is_pointer<int**>::value,              "int** is a pointer!");
478 static_assert(!fbl::is_pointer<const int>::value,          "const int is not a pointer!");
479 static_assert(!fbl::is_pointer<volatile int>::value,       "volatile int is not a pointer!");
480 static_assert(!fbl::is_pointer<const volatile int>::value, "const volatile int is not a pointer!");
482 static_assert( fbl::is_pointer<const int*>::value,          "const int* is a pointer!");
483 static_assert( fbl::is_pointer<volatile int*>::value,       "volatile int* is a pointer!");
484 static_assert( fbl::is_pointer<const volatile int*>::value, "const volatile int* is a pointer!");
486 static_assert( fbl::is_pointer<int* const >::value,          "int* const is a pointer!");
487 static_assert( fbl::is_pointer<int* volatile >::value,       "int* volatile is a pointer!");
488 static_assert( fbl::is_pointer<int* const volatile >::value, "int* const volatile is a pointer!");
490 static_assert( fbl::is_pointer<const int* const >::value,    "const int* const is a pointer!");
491 static_assert( fbl::is_pointer<const int* volatile >::value, "const int* volatile is a pointer!");
492 static_assert( fbl::is_pointer<const int* const volatile>::value,
495 static_assert( fbl::is_pointer<volatile int* const >::value, "volatile int* const is a pointer!");
496 static_assert( fbl::is_pointer<volatile int* volatile >::value,
498 static_assert( fbl::is_pointer<volatile int* const volatile>::value,
501 static_assert( fbl::is_pointer<const volatile int* const >::value,
503 static_assert( fbl::is_pointer<const volatile int* volatile >::value,
505 static_assert( fbl::is_pointer<const volatile int* const volatile>::value,
508 static_assert(!fbl::is_pointer<decltype(&StructType::MemberFunction)>::value,
510 static_assert(!fbl::is_pointer<decltype(&StructType::member_variable)>::value,
513 static_assert( fbl::is_pointer<decltype(&StructType::StaticMemberFunction)>::value,
515 static_assert( fbl::is_pointer<decltype(&StructType::static_member_variable)>::value,
518 static_assert( fbl::is_pointer<decltype(&SomeGlobalFunc)>::value,
520 static_assert( fbl::is_pointer<decltype(&SomeStaticFunc)>::value,
522 static_assert(!fbl::is_pointer<decltype(nullptr)>::value,
533 using icp = fbl::is_convertible_pointer<From, To>;
555 static_assert(fbl::is_same<fbl::conditional<true, int, bool>::type, int>::value, "wrong type");
556 static_assert(fbl::is_same<fbl::conditional<false, int, bool>::type, bool>::value, "wrong type");
639 static_assert(!fbl::is_function<int>::value, "");
640 static_assert(!fbl::is_function<int[]>::value, "");
641 static_assert(!fbl::is_function<int[1]>::value, "");
642 static_assert(!fbl::is_function<int*>::value, "");
643 static_assert(!fbl::is_function<int&>::value, "");
644 static_assert(!fbl::is_function<int&&>::value, "");
646 static_assert(!fbl::is_function<float>::value, "");
647 static_assert(!fbl::is_function<float[]>::value, "");
648 static_assert(!fbl::is_function<float[1]>::value, "");
649 static_assert(!fbl::is_function<float*>::value, "");
650 static_assert(!fbl::is_function<float&>::value, "");
651 static_assert(!fbl::is_function<float&&>::value, "");
653 static_assert(!fbl::is_function<s>::value, "");
654 static_assert(!fbl::is_function<s[]>::value, "");
655 static_assert(!fbl::is_function<s[1]>::value, "");
656 static_assert(!fbl::is_function<s*>::value, "");
657 static_assert(!fbl::is_function<s&>::value, "");
658 static_assert(!fbl::is_function<s&&>::value, "");
660 static_assert(!fbl::is_function<u>::value, "");
661 static_assert(!fbl::is_function<u[]>::value, "");
662 static_assert(!fbl::is_function<u[1]>::value, "");
663 static_assert(!fbl::is_function<u*>::value, "");
664 static_assert(!fbl::is_function<u&>::value, "");
665 static_assert(!fbl::is_function<u&&>::value, "");
667 static_assert(!fbl::is_function<forward_s>::value, "");
668 static_assert(!fbl::is_function<forward_s[]>::value, "");
669 static_assert(!fbl::is_function<forward_s[1]>::value, "");
670 static_assert(!fbl::is_function<forward_s*>::value, "");
671 static_assert(!fbl::is_function<forward_s&>::value, "");
672 static_assert(!fbl::is_function<forward_s&&>::value, "");
674 static_assert(!fbl::is_function<decltype(nullptr)>::value, "");
675 static_assert(!fbl::is_function<decltype(nullptr)[]>::value, "");
676 static_assert(!fbl::is_function<decltype(nullptr)[1]>::value, "");
677 static_assert(!fbl::is_function<decltype(nullptr)*>::value, "");
678 static_assert(!fbl::is_function<decltype(nullptr)&>::value, "");
679 static_assert(!fbl::is_function<decltype(nullptr)&&>::value, "");
683 static_assert(!fbl::is_function<void>::value, "");
684 static_assert(!fbl::is_function<void*>::value, "");
687 static_assert(!fbl::is_function<member_function_pointer>::value, "");
688 static_assert(!fbl::is_function<member_function_pointer[]>::value, "");
689 static_assert(!fbl::is_function<member_function_pointer[1]>::value, "");
690 static_assert(!fbl::is_function<member_function_pointer*>::value, "");
691 static_assert(!fbl::is_function<member_function_pointer&>::value, "");
692 static_assert(!fbl::is_function<member_function_pointer&&>::value, "");
698 static_assert(fbl::is_function<void_to_void>::value, "");
699 static_assert(!fbl::is_function<void_to_void*>::value, "");
700 static_assert(!fbl::is_function<void_to_void&>::value, "");
701 static_assert(!fbl::is_function<void_to_void&&>::value, "");
704 static_assert(fbl::is_function<void_to_int>::value, "");
705 static_assert(!fbl::is_function<void_to_int*>::value, "");
706 static_assert(!fbl::is_function<void_to_int&>::value, "");
707 static_assert(!fbl::is_function<void_to_int&&>::value, "");
710 static_assert(fbl::is_function<int_to_void>::value, "");
711 static_assert(!fbl::is_function<int_to_void*>::value, "");
712 static_assert(!fbl::is_function<int_to_void&>::value, "");
713 static_assert(!fbl::is_function<int_to_void&&>::value, "");
716 static_assert(fbl::is_function<int_to_int>::value, "");
717 static_assert(!fbl::is_function<int_to_int*>::value, "");
718 static_assert(!fbl::is_function<int_to_int&>::value, "");
719 static_assert(!fbl::is_function<int_to_int&&>::value, "");
722 static_assert(fbl::is_function<s_to_void>::value, "");
723 static_assert(!fbl::is_function<s_to_void*>::value, "");
724 static_assert(!fbl::is_function<s_to_void&>::value, "");
725 static_assert(!fbl::is_function<s_to_void&&>::value, "");
728 static_assert(fbl::is_function<u_to_void>::value, "");
729 static_assert(!fbl::is_function<u_to_void*>::value, "");
730 static_assert(!fbl::is_function<u_to_void&>::value, "");
731 static_assert(!fbl::is_function<u_to_void&&>::value, "");
734 static_assert(fbl::is_function<va_to_void>::value, "");
735 static_assert(!fbl::is_function<va_to_void*>::value, "");
736 static_assert(!fbl::is_function<va_to_void&>::value, "");
737 static_assert(!fbl::is_function<va_to_void&&>::value, "");
740 static_assert(fbl::is_function<int_va_to_void>::value, "");
741 static_assert(!fbl::is_function<int_va_to_void*>::value, "");
742 static_assert(!fbl::is_function<int_va_to_void&>::value, "");
743 static_assert(!fbl::is_function<int_va_to_void&&>::value, "");
747 static_assert(fbl::is_pointer<decltype(function_pointer_inside_lambda)>::value, "");
748 using function_type = fbl::remove_pointer<decltype(function_pointer_inside_lambda)>::type;
749 static_assert(fbl::is_function<function_type>::value, "");