1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10
11 // template <class T>
12 // constexpr bool has_single_bit(T x) noexcept;
13
14 // Constraints: T is an unsigned integer type
15
16 #include <bit>
17 #include <cassert>
18 #include <cstdint>
19 #include <type_traits>
20
21 #include "test_macros.h"
22
23 struct A {};
24 enum E1 : unsigned char { rEd };
25 enum class E2 : unsigned char { red };
26
27 template <class T>
test()28 constexpr bool test()
29 {
30 ASSERT_SAME_TYPE(decltype(std::has_single_bit(T())), bool);
31 ASSERT_NOEXCEPT(std::has_single_bit(T()));
32 T max = std::numeric_limits<T>::max();
33
34 assert(!std::has_single_bit(T(0)));
35 assert( std::has_single_bit(T(1)));
36 assert( std::has_single_bit(T(2)));
37 assert(!std::has_single_bit(T(3)));
38 assert( std::has_single_bit(T(4)));
39 assert(!std::has_single_bit(T(5)));
40 assert(!std::has_single_bit(T(6)));
41 assert(!std::has_single_bit(T(7)));
42 assert( std::has_single_bit(T(8)));
43 assert(!std::has_single_bit(T(9)));
44 assert(!std::has_single_bit(T(127)));
45 assert( std::has_single_bit(T(128)));
46 assert(!std::has_single_bit(T(129)));
47 assert(!std::has_single_bit(max));
48
49 #ifndef TEST_HAS_NO_INT128
50 if constexpr (std::is_same_v<T, __uint128_t>) {
51 T val = T(1) << 32;
52 assert(!std::has_single_bit(val-1));
53 assert( std::has_single_bit(val));
54 assert(!std::has_single_bit(val+1));
55 val <<= 60;
56 assert(!std::has_single_bit(val-1));
57 assert( std::has_single_bit(val));
58 assert(!std::has_single_bit(val+1));
59
60 T x = (T(1) << 63);
61 T y = (T(1) << 64);
62 assert( std::has_single_bit(x));
63 assert( std::has_single_bit(y));
64 assert(!std::has_single_bit(x + y));
65 }
66 #endif
67
68 return true;
69 }
70
main(int,char **)71 int main(int, char**)
72 {
73 {
74 auto lambda = [](auto x) -> decltype(std::has_single_bit(x)) {};
75 using L = decltype(lambda);
76
77 static_assert(!std::is_invocable_v<L, signed char>);
78 static_assert(!std::is_invocable_v<L, short>);
79 static_assert(!std::is_invocable_v<L, int>);
80 static_assert(!std::is_invocable_v<L, long>);
81 static_assert(!std::is_invocable_v<L, long long>);
82 #ifndef TEST_HAS_NO_INT128
83 static_assert(!std::is_invocable_v<L, __int128_t>);
84 #endif
85
86 static_assert(!std::is_invocable_v<L, int8_t>);
87 static_assert(!std::is_invocable_v<L, int16_t>);
88 static_assert(!std::is_invocable_v<L, int32_t>);
89 static_assert(!std::is_invocable_v<L, int64_t>);
90 static_assert(!std::is_invocable_v<L, intmax_t>);
91 static_assert(!std::is_invocable_v<L, intptr_t>);
92 static_assert(!std::is_invocable_v<L, ptrdiff_t>);
93
94 static_assert(!std::is_invocable_v<L, bool>);
95 static_assert(!std::is_invocable_v<L, char>);
96 static_assert(!std::is_invocable_v<L, wchar_t>);
97 #ifndef TEST_HAS_NO_CHAR8_T
98 static_assert(!std::is_invocable_v<L, char8_t>);
99 #endif
100 static_assert(!std::is_invocable_v<L, char16_t>);
101 static_assert(!std::is_invocable_v<L, char32_t>);
102
103 static_assert(!std::is_invocable_v<L, A>);
104 static_assert(!std::is_invocable_v<L, A*>);
105 static_assert(!std::is_invocable_v<L, E1>);
106 static_assert(!std::is_invocable_v<L, E2>);
107 }
108
109 static_assert(test<unsigned char>());
110 static_assert(test<unsigned short>());
111 static_assert(test<unsigned int>());
112 static_assert(test<unsigned long>());
113 static_assert(test<unsigned long long>());
114 #ifndef TEST_HAS_NO_INT128
115 static_assert(test<__uint128_t>());
116 #endif
117 static_assert(test<uint8_t>());
118 static_assert(test<uint16_t>());
119 static_assert(test<uint32_t>());
120 static_assert(test<uint64_t>());
121 static_assert(test<uintmax_t>());
122 static_assert(test<uintptr_t>());
123 static_assert(test<size_t>());
124
125 test<unsigned char>();
126 test<unsigned short>();
127 test<unsigned int>();
128 test<unsigned long>();
129 test<unsigned long long>();
130 #ifndef TEST_HAS_NO_INT128
131 test<__uint128_t>();
132 #endif
133 test<uint8_t>();
134 test<uint16_t>();
135 test<uint32_t>();
136 test<uint64_t>();
137 test<uintmax_t>();
138 test<uintptr_t>();
139 test<size_t>();
140
141 return 0;
142 }
143