1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
10
11 // [utility.underlying], to_underlying
12 // template <class T>
13 // constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
14
15 #include <utility>
16 #include <cassert>
17 #include <cstdint>
18 #include <limits>
19
20 #include "test_macros.h"
21
22 enum class e_default { a = 0, b = 1, c = 2 };
23 enum class e_ushort : unsigned short { d = 10, e = 25, f = 50 };
24 enum class e_longlong : long long {
25 low = std::numeric_limits<long long>::min(),
26 high = std::numeric_limits<long long>::max()
27 };
28 enum e_non_class { enum_a = 10, enum_b = 11, enum_c = 12 };
29 enum e_int : int {
30 enum_min = std::numeric_limits<int>::min(),
31 enum_max = std::numeric_limits<int>::max()
32 };
33 enum class e_bool : std::uint8_t { f = 0, t = 1 };
34
35 struct WithBitfieldEnums {
36 e_default e1 : 3;
37 e_ushort e2 : 6;
38 e_bool e3 : 1;
39 };
40
test()41 constexpr bool test() {
42 ASSERT_NOEXCEPT(std::to_underlying(e_default::a));
43 ASSERT_SAME_TYPE(int, decltype(std::to_underlying(e_default::a)));
44 ASSERT_SAME_TYPE(unsigned short, decltype(std::to_underlying(e_ushort::d)));
45 ASSERT_SAME_TYPE(long long, decltype(std::to_underlying(e_longlong::low)));
46 ASSERT_SAME_TYPE(int, decltype(std::to_underlying(enum_min)));
47 ASSERT_SAME_TYPE(int, decltype(std::to_underlying(enum_max)));
48
49 assert(0 == std::to_underlying(e_default::a));
50 assert(1 == std::to_underlying(e_default::b));
51 assert(2 == std::to_underlying(e_default::c));
52
53 assert(10 == std::to_underlying(e_ushort::d));
54 assert(25 == std::to_underlying(e_ushort::e));
55 assert(50 == std::to_underlying(e_ushort::f));
56
57 // Check no truncating.
58 assert(std::numeric_limits<long long>::min() ==
59 std::to_underlying(e_longlong::low));
60 assert(std::numeric_limits<long long>::max() ==
61 std::to_underlying(e_longlong::high));
62
63 assert(10 == std::to_underlying(enum_a));
64 assert(11 == std::to_underlying(enum_b));
65 assert(12 == std::to_underlying(enum_c));
66 assert(std::numeric_limits<int>::min() == std::to_underlying(enum_min));
67 assert(std::numeric_limits<int>::max() == std::to_underlying(enum_max));
68
69 WithBitfieldEnums bf;
70 bf.e1 = static_cast<e_default>(3);
71 bf.e2 = e_ushort::e;
72 bf.e3 = e_bool::t;
73 assert(3 == std::to_underlying(bf.e1));
74 assert(25 == std::to_underlying(bf.e2));
75 assert(1 == std::to_underlying(bf.e3));
76
77 return true;
78 }
79
main(int,char **)80 int main(int, char**) {
81 test();
82 static_assert(test());
83
84 return 0;
85 }
86