| /external/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ |
| values.pass.cpp | 52 static_assert((E::word_size == 32), "");
53 static_assert((E::state_size == 624), "");
54 static_assert((E::shift_size == 397), "");
55 static_assert((E::mask_bits == 31), "");
56 static_assert((E::xor_mask == 0x9908b0df), "");
57 static_assert((E::tempering_u == 11), "");
58 static_assert((E::tempering_d == 0xffffffff), "");
59 static_assert((E::tempering_s == 7), "");
60 static_assert((E::tempering_b == 0x9d2c5680), "");
61 static_assert((E::tempering_t == 15), "")
[all...] |
| /external/libcxx/test/std/thread/futures/futures.overview/ |
| is_error_code_enum_future_errc.pass.cpp | 21 static_assert(std::is_error_code_enum <std::future_errc>::value, "");
23 static_assert(std::is_error_code_enum_v<std::future_errc>, "");
|
| /external/libcxx/test/std/utilities/meta/meta.help/ |
| bool_constant.pass.cpp | 23 static_assert(_t::value, "");
24 static_assert((std::is_same<_t::value_type, bool>::value), "");
25 static_assert((std::is_same<_t::type, _t>::value), "");
26 static_assert((_t() == true), "");
29 static_assert(!_f::value, "");
30 static_assert((std::is_same<_f::value_type, bool>::value), "");
31 static_assert((std::is_same<_f::type, _f>::value), "");
32 static_assert((_f() == false), "");
|
| /frameworks/av/media/codec2/tests/ |
| C2_test.cpp | 33 static_assert(std::is_same<decltype(min_i32_i32), const int32_t>::value, "should be int32_t");
35 static_assert(std::is_same<decltype(min_i32_i64), const int64_t>::value, "should be int64_t");
37 static_assert(std::is_same<decltype(min_i8_i32), const int32_t>::value, "should be int32_t");
39 static_assert(c2_const_checker<min_i32_i32>::num() == 1, "should be 1");
40 static_assert(c2_const_checker<min_i32_i64>::num() == 2, "should be 2");
41 static_assert(c2_const_checker<min_i8_i32>::num() == 0xffffffff, "should be 0xffffffff");
44 static_assert(std::is_same<decltype(min_u32_u32), const uint32_t>::value, "should be uint32_t");
46 static_assert(std::is_same<decltype(min_u32_u64), const uint32_t>::value, "should be uint32_t");
48 static_assert(std::is_same<decltype(min_u32_u8), const uint8_t>::value, "should be uint8_t");
50 static_assert(c2_const_checker<min_u32_u32>::num() == 1, "should be 1")
[all...] |
| /external/libcxx/test/std/experimental/simd/simd.traits/ |
| is_simd.pass.cpp | 27 static_assert(ex::is_simd<ex::native_simd<int8_t>>::value, "");
28 static_assert(ex::is_simd<ex::native_simd<int16_t>>::value, "");
29 static_assert(ex::is_simd<ex::native_simd<int32_t>>::value, "");
30 static_assert(ex::is_simd<ex::native_simd<int64_t>>::value, "");
31 static_assert(ex::is_simd<ex::native_simd<uint8_t>>::value, "");
32 static_assert(ex::is_simd<ex::native_simd<uint16_t>>::value, "");
33 static_assert(ex::is_simd<ex::native_simd<uint32_t>>::value, "");
34 static_assert(ex::is_simd<ex::native_simd<uint64_t>>::value, "");
35 static_assert(ex::is_simd<ex::native_simd<float>>::value, "");
36 static_assert(ex::is_simd<ex::native_simd<double>>::value, "")
[all...] |
| is_simd_mask.pass.cpp | 27 static_assert(ex::is_simd_mask<ex::native_simd_mask<int8_t>>::value, "");
28 static_assert(ex::is_simd_mask<ex::native_simd_mask<int16_t>>::value, "");
29 static_assert(ex::is_simd_mask<ex::native_simd_mask<int32_t>>::value, "");
30 static_assert(ex::is_simd_mask<ex::native_simd_mask<int64_t>>::value, "");
31 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint8_t>>::value, "");
32 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint16_t>>::value, "");
33 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint32_t>>::value, "");
34 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint64_t>>::value, "");
35 static_assert(ex::is_simd_mask<ex::native_simd_mask<float>>::value, "");
36 static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, "")
[all...] |
| /external/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/ |
| aligned_union.pass.cpp | 28 static_assert(std::is_same<std::aligned_union_t<10, char>, T1>::value, "" );
30 static_assert(std::is_trivial<T1>::value, "");
31 static_assert(std::is_standard_layout<T1>::value, "");
32 static_assert(std::alignment_of<T1>::value == 1, "");
33 static_assert(sizeof(T1) == 10, "");
38 static_assert(std::is_same<std::aligned_union_t<10, short>, T1>::value, "" );
40 static_assert(std::is_trivial<T1>::value, "");
41 static_assert(std::is_standard_layout<T1>::value, "");
42 static_assert(std::alignment_of<T1>::value == 2, "");
43 static_assert(sizeof(T1) == 10, "")
[all...] |
| aligned_storage.pass.cpp | 26 static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "");
29 static_assert(std::is_pod<T1>::value, "");
31 static_assert(std::is_trivial<T1>::value, "");
32 static_assert(std::is_standard_layout<T1>::value, "");
33 static_assert(std::alignment_of<T1>::value == 1, "");
34 static_assert(sizeof(T1) == 10, "");
39 static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "");
42 static_assert(std::is_pod<T1>::value, "");
44 static_assert(std::is_trivial<T1>::value, "");
45 static_assert(std::is_standard_layout<T1>::value, "")
[all...] |
| conditional.pass.cpp | 20 static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
21 static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
23 static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
24 static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
|
| enable_if.pass.cpp | 20 static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
21 static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
23 static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
24 static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
|
| /external/clang/test/CXX/expr/expr.prim/expr.prim.lambda/ |
| p18.cpp | 21 static_assert(is_same<decltype(((r))), float const&>::value,
23 static_assert(is_same<decltype(x), float>::value, "should be float");
24 static_assert(is_same<decltype((x)), const float&>::value,
26 static_assert(is_same<decltype(r), float&>::value, "should be float&");
27 static_assert(is_same<decltype(ir), int&>::value, "should be int&");
28 static_assert(is_same<decltype((ir)), int&>::value, "should be int&");
29 static_assert(is_same<decltype(irc), const int&>::value,
31 static_assert(is_same<decltype((irc)), const int&>::value,
37 static_assert(is_same<decltype(x), float>::value, "should be float");
38 static_assert(is_same<decltype((x)), float&>::value,
[all...] |
| /external/libcxx/test/std/utilities/meta/meta.rel/ |
| is_same.pass.cpp | 21 static_assert(( std::is_same<T, U>::value), "");
22 static_assert((!std::is_same<const T, U>::value), "");
23 static_assert((!std::is_same<T, const U>::value), "");
24 static_assert(( std::is_same<const T, const U>::value), "");
26 static_assert(( std::is_same_v<T, U>), "");
27 static_assert((!std::is_same_v<const T, U>), "");
28 static_assert((!std::is_same_v<T, const U>), "");
29 static_assert(( std::is_same_v<const T, const U>), "");
36 static_assert((std::is_same<T, U>::value), "");
37 static_assert((std::is_same<const T, U>::value), "")
[all...] |
| /external/libcxx/test/libcxx/utilities/any/ |
| small_type.pass.cpp | 62 static_assert(_IsSmallObject<small>::value, "");
63 static_assert(_IsSmallObject<void*>::value, "");
64 static_assert(!_IsSmallObject<SmallThrowsDtor>::value, "");
65 static_assert(!_IsSmallObject<large>::value, "");
70 static_assert(sizeof(T) == BufferSize, "");
71 static_assert(alignof(T) < BufferAlignment, "");
72 static_assert(_IsSmallObject<T>::value, "");
78 static_assert(sizeof(T) < BufferSize, "");
79 static_assert(alignof(T) == BufferAlignment, "");
80 static_assert(_IsSmallObject<T>::value, "")
[all...] |
| /external/libcxx/test/std/containers/views/span.cons/ |
| assign.pass.cpp | 73 static_assert(std::size(spans) == 13, "" );
76 static_assert(doAssign(spans[0], spans[0]), "");
77 static_assert(doAssign(spans[0], spans[1]), "");
78 static_assert(doAssign(spans[0], spans[2]), "");
79 static_assert(doAssign(spans[0], spans[3]), "");
80 static_assert(doAssign(spans[0], spans[4]), "");
81 static_assert(doAssign(spans[0], spans[5]), "");
82 static_assert(doAssign(spans[0], spans[6]), "");
83 static_assert(doAssign(spans[0], spans[7]), "");
84 static_assert(doAssign(spans[0], spans[8]), "")
[all...] |
| /art/libartbase/base/ |
| bit_utils_test.cc | 27 static_assert(31 == CLZ<uint32_t>(1u), "TestCLZ32#1");
28 static_assert(30 == CLZ<uint32_t>(2u), "TestCLZ32#2");
29 static_assert(16 == CLZ<uint32_t>(0x00008765u), "TestCLZ32#3");
30 static_assert(15 == CLZ<uint32_t>(0x00012345u), "TestCLZ32#4");
31 static_assert(1 == CLZ<uint32_t>(0x43214321u), "TestCLZ32#5");
32 static_assert(0 == CLZ<uint32_t>(0x87654321u), "TestCLZ32#6");
35 static_assert(63 == CLZ<uint64_t>(UINT64_C(1)), "TestCLZ64#1");
36 static_assert(62 == CLZ<uint64_t>(UINT64_C(3)), "TestCLZ64#2");
37 static_assert(48 == CLZ<uint64_t>(UINT64_C(0x00008765)), "TestCLZ64#3");
38 static_assert(32 == CLZ<uint64_t>(UINT64_C(0x87654321)), "TestCLZ64#4")
[all...] |
| /external/libchrome/base/ |
| template_util_unittest.cc | 30 static_assert(!is_non_const_reference<int>::value, "IsNonConstReference");
31 static_assert(!is_non_const_reference<const int&>::value,
33 static_assert(is_non_const_reference<int&>::value, "IsNonConstReference");
36 static_assert(internal::SupportsOstreamOperator<int>::value,
38 static_assert(internal::SupportsOstreamOperator<const char*>::value,
40 static_assert(internal::SupportsOstreamOperator<std::string>::value,
44 static_assert(internal::SupportsOstreamOperator<SimpleEnum>::value,
46 static_assert(internal::SupportsOstreamOperator<const SimpleEnum&>::value,
48 static_assert(internal::SupportsOstreamOperator<EnumWithExplicitType>::value,
50 static_assert(
[all...] |
| /external/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/ |
| non_trivial_copy_move_ABI.pass.cpp | 56 static_assert(HasNonTrivialABI<NonTrivialDtor>::value, "");
62 static_assert(HasNonTrivialABI<NonTrivialCopy>::value, "");
69 static_assert(HasNonTrivialABI<NonTrivialMove>::value, "");
75 static_assert(!HasNonTrivialABI<DeletedCopy>::value, "");
80 static_assert(!HasNonTrivialABI<TrivialMove>::value, "");
85 static_assert(!HasNonTrivialABI<Trivial>::value, "");
93 static_assert(std::is_copy_constructible<P>::value, "");
94 static_assert(HasNonTrivialABI<P>::value, "");
99 static_assert(std::is_move_constructible<P>::value, "");
100 static_assert(HasNonTrivialABI<P>::value, "")
[all...] |
| trivial_copy_move_ABI.pass.cpp | 51 static_assert(!HasTrivialABI<NonTrivialDtor>::value, "");
57 static_assert(!HasTrivialABI<NonTrivialCopy>::value, "");
64 static_assert(!HasTrivialABI<NonTrivialMove>::value, "");
70 static_assert(HasTrivialABI<DeletedCopy>::value, "");
75 static_assert(HasTrivialABI<TrivialMove>::value, "");
80 static_assert(HasTrivialABI<Trivial>::value, "");
88 static_assert(std::is_copy_constructible<P>::value, "");
89 static_assert(HasTrivialABI<P>::value, "");
94 static_assert(std::is_move_constructible<P>::value, "");
95 static_assert(HasTrivialABI<P>::value, "")
[all...] |
| /external/clang/test/CXX/special/class.copy/ |
| p12-0x.cpp | 6 static_assert(B == __has_trivial_copy(T), "");
7 static_assert(B == __is_trivially_constructible(T, T), "");
8 static_assert(B == __is_trivially_constructible(T, const T &), "");
9 static_assert(B == __is_trivially_constructible(T, T &&), "");
57 static_assert(!__is_trivially_constructible(MutableTemplateCtorMember, const MutableTemplateCtorMember &), "");
58 static_assert(__is_trivially_constructible(MutableTemplateCtorMember, MutableTemplateCtorMember &&), "");
64 static_assert(!__is_trivially_constructible(MutableTemplateCtorMember2, const MutableTemplateCtorMember2 &), "");
65 static_assert(__is_trivially_constructible(MutableTemplateCtorMember2, MutableTemplateCtorMember2 &&), "");
76 static_assert(!__has_trivial_copy(TNT), "lie deliberately for gcc compatibility");
77 static_assert(__is_trivially_constructible(TNT, TNT), "")
[all...] |
| /external/clang/test/Modules/ |
| merge-decl-context.cpp | 36 static_assert(Aggregate{.member = 1}.member == 1, "");
|
| /external/clang/test/SemaCXX/ |
| alignof-sizeof-reference.cpp | 7 static_assert(alignof(r) == 1, "bad alignment"); // expected-warning {{GNU extension}}
8 static_assert(alignof(char&) == 1, "bad alignment");
9 static_assert(sizeof(r) == 1, "bad size");
10 static_assert(sizeof(char&) == 1, "bad size");
|
| /external/google-fruit/include/fruit/impl/ |
| fruit_assert.h | 23 #define FruitStaticAssert(...) static_assert(fruit::impl::meta::Eval<__VA_ARGS__>::value, "")
29 #define FruitStaticAssert(...) static_assert(true, "")
34 #define FruitDelegateCheck(...) static_assert(true || sizeof(fruit::impl::meta::Eval<__VA_ARGS__>), "")
35 #define FruitDisplayErrorForType(...) static_assert(false && sizeof(fruit::impl::meta::Eval<__VA_ARGS__>), "")
|
| /external/libcxx/test/libcxx/iterators/ |
| trivial_iterators.pass.cpp | 97 static_assert(( std::__libcpp_is_trivial_iterator<char *>::value), "");
98 static_assert(( std::__libcpp_is_trivial_iterator<const char *>::value), "");
99 static_assert(( std::__libcpp_is_trivial_iterator<int *>::value), "");
100 static_assert(( std::__libcpp_is_trivial_iterator<T *>::value), "");
102 static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<char *> > ::value), "");
103 static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<const char *> >::value), "");
104 static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<int *> > ::value), "");
105 static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<T *> > ::value), "");
107 static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<char *> > ::value), "");
108 static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<const char *> >::value), "")
[all...] |
| /external/libcxx/test/std/utilities/function.objects/bitwise.operations/ |
| transparent.pass.cpp | 27 static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
28 static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
29 static_assert ( is_transparent<std::bit_and<void>>::value, "" );
30 static_assert ( is_transparent<std::bit_and<>>::value, "" );
32 static_assert ( !is_transparent<std::bit_or<int>>::value, "" );
33 static_assert ( !is_transparent<std::bit_or<std::string>>::value, "" );
34 static_assert ( is_transparent<std::bit_or<void>>::value, "" );
35 static_assert ( is_transparent<std::bit_or<>>::value, "" );
37 static_assert ( !is_transparent<std::bit_xor<int>>::value, "" );
38 static_assert ( !is_transparent<std::bit_xor<std::string>>::value, "" )
[all...] |
| /external/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/ |
| is_array.pass.cpp | 21 static_assert( std::is_array<T>::value, "");
22 static_assert( std::is_array<const T>::value, "");
23 static_assert( std::is_array<volatile T>::value, "");
24 static_assert( std::is_array<const volatile T>::value, "");
26 static_assert( std::is_array_v<T>, "");
27 static_assert( std::is_array_v<const T>, "");
28 static_assert( std::is_array_v<volatile T>, "");
29 static_assert( std::is_array_v<const volatile T>, "");
36 static_assert(!std::is_array<T>::value, "");
37 static_assert(!std::is_array<const T>::value, "")
[all...] |
