aboutsummaryrefslogtreecommitdiff
path: root/gdb/unittests/enum-flags-selftests.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/unittests/enum-flags-selftests.c')
-rw-r--r--gdb/unittests/enum-flags-selftests.c322
1 files changed, 147 insertions, 175 deletions
diff --git a/gdb/unittests/enum-flags-selftests.c b/gdb/unittests/enum-flags-selftests.c
index b55d8c3..3eb0f52 100644
--- a/gdb/unittests/enum-flags-selftests.c
+++ b/gdb/unittests/enum-flags-selftests.c
@@ -1,6 +1,6 @@
/* Self tests for enum-flags for GDB, the GNU debugger.
- Copyright (C) 2016-2024 Free Software Foundation, Inc.
+ Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of GDB.
@@ -29,49 +29,49 @@ namespace enum_flags_tests {
make it simpler to use. They could be named differently. */
/* A "real enum". */
-enum RE
- {
- RE_FLAG1 = 1 << 1,
- RE_FLAG2 = 1 << 2,
- };
+enum RawEnum
+{
+ RawEnum_Flag1 = 1 << 1,
+ RawEnum_Flag2 = 1 << 2,
+};
/* Another "real enum". */
-enum RE2
- {
- RE2_FLAG1 = 1 << 1,
- RE2_FLAG2 = 1 << 2,
- };
+enum RawEnum2
+{
+ RawEnum2_Flag1 = 1 << 1,
+ RawEnum2_Flag2 = 1 << 2,
+};
/* An unsigned "real enum". */
-enum URE : unsigned
- {
- URE_FLAG1 = 1 << 1,
- URE_FLAG2 = 1 << 2,
- URE_FLAG3 = 0xffffffff,
- };
+enum UnsignedRawEnum : unsigned
+{
+ UnsignedRawEnum_Flag1 = 1 << 1,
+ UnsignedRawEnum_Flag2 = 1 << 2,
+ UnsignedRawEnum_Flag3 = 0xffffffff,
+};
/* A non-flags enum. */
-enum NF
- {
- NF_FLAG1 = 1 << 1,
- NF_FLAG2 = 1 << 2,
- };
+enum NonFlagsEnum
+{
+ NonFlagsEnum_Flag1 = 1 << 1,
+ NonFlagsEnum_Flag2 = 1 << 2,
+};
/* The corresponding "enum flags" types. */
-DEF_ENUM_FLAGS_TYPE (RE, EF);
-DEF_ENUM_FLAGS_TYPE (RE2, EF2);
-DEF_ENUM_FLAGS_TYPE (URE, UEF);
+DEF_ENUM_FLAGS_TYPE (RawEnum, EnumFlag);
+DEF_ENUM_FLAGS_TYPE (RawEnum2, EnumFlag2);
+DEF_ENUM_FLAGS_TYPE (UnsignedRawEnum, UnsignedEnumFlag);
/* So that std::vectors of types that have enum_flags fields can
reallocate efficiently memcpy. */
-static_assert (std::is_trivially_copyable<EF>::value);
+static_assert (std::is_trivially_copyable<EnumFlag>::value);
/* A couple globals used as lvalues in the CHECK_VALID expressions
below. Their names (and types) match the uppercase type names
exposed by CHECK_VALID just to make the expressions easier to
follow. */
-static RE re ATTRIBUTE_UNUSED;
-static EF ef ATTRIBUTE_UNUSED;
+static RawEnum re ATTRIBUTE_UNUSED;
+static EnumFlag ef ATTRIBUTE_UNUSED;
/* First, compile-time tests that:
@@ -82,30 +82,32 @@ static EF ef ATTRIBUTE_UNUSED;
types do compile and that they return the correct type.
*/
-#define CHECK_VALID(VALID, EXPR_TYPE, EXPR) \
- CHECK_VALID_EXPR_6 (EF, RE, EF2, RE2, UEF, URE, VALID, EXPR_TYPE, EXPR)
+#define CHECK_VALID(VALID, EXPR_TYPE, EXPR) \
+ CHECK_VALID_EXPR_6 (EnumFlag, RawEnum, EnumFlag2, RawEnum2, \
+ UnsignedEnumFlag, UnsignedRawEnum, VALID, EXPR_TYPE, \
+ EXPR)
-typedef std::underlying_type<RE>::type und;
+using und = std::underlying_type<RawEnum>::type;
/* Test construction / conversion from/to different types. */
/* RE/EF -> underlying (explicit) */
-CHECK_VALID (true, und, und (RE ()))
-CHECK_VALID (true, und, und (EF ()))
+CHECK_VALID (true, und, und (RawEnum ()))
+CHECK_VALID (true, und, und (EnumFlag ()))
/* RE/EF -> int (explicit) */
-CHECK_VALID (true, int, int (RE ()))
-CHECK_VALID (true, int, int (EF ()))
+CHECK_VALID (true, int, int (RawEnum ()))
+CHECK_VALID (true, int, int (EnumFlag ()))
/* other -> RE */
/* You can construct a raw enum value from an int explicitly to punch
a hole in the type system if need to. */
-CHECK_VALID (true, RE, RE (1))
-CHECK_VALID (true, RE, RE (RE2 ()))
-CHECK_VALID (false, void, RE (EF2 ()))
-CHECK_VALID (true, RE, RE (RE ()))
-CHECK_VALID (false, void, RE (EF ()))
+CHECK_VALID (true, RawEnum, RawEnum (1))
+CHECK_VALID (true, RawEnum, RawEnum (RawEnum2 ()))
+CHECK_VALID (false, void, RawEnum (EnumFlag2 ()))
+CHECK_VALID (true, RawEnum, RawEnum (RawEnum ()))
+CHECK_VALID (false, void, RawEnum (EnumFlag ()))
/* other -> EF. */
@@ -113,152 +115,125 @@ CHECK_VALID (false, void, RE (EF ()))
enum. Unlike with raw enums, you can't construct an enum flags
from an integer nor from an unrelated enum type explicitly. Add an
intermediate conversion via the raw enum if you really need it. */
-CHECK_VALID (false, void, EF (1))
-CHECK_VALID (false, void, EF (1u))
-CHECK_VALID (false, void, EF (RE2 ()))
-CHECK_VALID (false, void, EF (EF2 ()))
-CHECK_VALID (true, EF, EF (RE ()))
-CHECK_VALID (true, EF, EF (EF ()))
+CHECK_VALID (false, void, EnumFlag (1))
+CHECK_VALID (false, void, EnumFlag (1u))
+CHECK_VALID (false, void, EnumFlag (RawEnum2 ()))
+CHECK_VALID (false, void, EnumFlag (EnumFlag2 ()))
+CHECK_VALID (true, EnumFlag, EnumFlag (RawEnum ()))
+CHECK_VALID (true, EnumFlag, EnumFlag (EnumFlag ()))
/* Test operators. */
/* operator OP (raw_enum, int) */
-CHECK_VALID (false, void, RE () | 1)
-CHECK_VALID (false, void, RE () & 1)
-CHECK_VALID (false, void, RE () ^ 1)
+CHECK_VALID (false, void, RawEnum () | 1)
+CHECK_VALID (false, void, RawEnum () & 1)
+CHECK_VALID (false, void, RawEnum () ^ 1)
/* operator OP (int, raw_enum) */
-CHECK_VALID (false, void, 1 | RE ())
-CHECK_VALID (false, void, 1 & RE ())
-CHECK_VALID (false, void, 1 ^ RE ())
+CHECK_VALID (false, void, 1 | RawEnum ())
+CHECK_VALID (false, void, 1 & RawEnum ())
+CHECK_VALID (false, void, 1 ^ RawEnum ())
/* operator OP (enum_flags, int) */
-CHECK_VALID (false, void, EF () | 1)
-CHECK_VALID (false, void, EF () & 1)
-CHECK_VALID (false, void, EF () ^ 1)
+CHECK_VALID (false, void, EnumFlag () | 1)
+CHECK_VALID (false, void, EnumFlag () & 1)
+CHECK_VALID (false, void, EnumFlag () ^ 1)
/* operator OP (int, enum_flags) */
-CHECK_VALID (false, void, 1 | EF ())
-CHECK_VALID (false, void, 1 & EF ())
-CHECK_VALID (false, void, 1 ^ EF ())
+CHECK_VALID (false, void, 1 | EnumFlag ())
+CHECK_VALID (false, void, 1 & EnumFlag ())
+CHECK_VALID (false, void, 1 ^ EnumFlag ())
/* operator OP (raw_enum, raw_enum) */
-CHECK_VALID (false, void, RE () | RE2 ())
-CHECK_VALID (false, void, RE () & RE2 ())
-CHECK_VALID (false, void, RE () ^ RE2 ())
-CHECK_VALID (true, RE, RE () | RE ())
-CHECK_VALID (true, RE, RE () & RE ())
-CHECK_VALID (true, RE, RE () ^ RE ())
+CHECK_VALID (false, void, RawEnum () | RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () & RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () ^ RawEnum2 ())
+CHECK_VALID (true, RawEnum, RawEnum () | RawEnum ())
+CHECK_VALID (true, RawEnum, RawEnum () & RawEnum ())
+CHECK_VALID (true, RawEnum, RawEnum () ^ RawEnum ())
/* operator OP (enum_flags, raw_enum) */
-CHECK_VALID (false, void, EF () | RE2 ())
-CHECK_VALID (false, void, EF () & RE2 ())
-CHECK_VALID (false, void, EF () ^ RE2 ())
-CHECK_VALID (true, EF, EF () | RE ())
-CHECK_VALID (true, EF, EF () & RE ())
-CHECK_VALID (true, EF, EF () ^ RE ())
+CHECK_VALID (false, void, EnumFlag () | RawEnum2 ())
+CHECK_VALID (false, void, EnumFlag () & RawEnum2 ())
+CHECK_VALID (false, void, EnumFlag () ^ RawEnum2 ())
+CHECK_VALID (true, EnumFlag, EnumFlag () | RawEnum ())
+CHECK_VALID (true, EnumFlag, EnumFlag () & RawEnum ())
+CHECK_VALID (true, EnumFlag, EnumFlag () ^ RawEnum ())
/* operator OP= (raw_enum, raw_enum), rvalue ref on the lhs. */
-CHECK_VALID (false, void, RE () |= RE2 ())
-CHECK_VALID (false, void, RE () &= RE2 ())
-CHECK_VALID (false, void, RE () ^= RE2 ())
-CHECK_VALID (false, void, RE () |= RE ())
-CHECK_VALID (false, void, RE () &= RE ())
-CHECK_VALID (false, void, RE () ^= RE ())
+CHECK_VALID (false, void, RawEnum () |= RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () &= RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () ^= RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () |= RawEnum ())
+CHECK_VALID (false, void, RawEnum () &= RawEnum ())
+CHECK_VALID (false, void, RawEnum () ^= RawEnum ())
/* operator OP= (raw_enum, raw_enum), lvalue ref on the lhs. */
-CHECK_VALID (false, void, re |= RE2 ())
-CHECK_VALID (false, void, re &= RE2 ())
-CHECK_VALID (false, void, re ^= RE2 ())
-CHECK_VALID (true, RE&, re |= RE ())
-CHECK_VALID (true, RE&, re &= RE ())
-CHECK_VALID (true, RE&, re ^= RE ())
+CHECK_VALID (false, void, re |= RawEnum2 ())
+CHECK_VALID (false, void, re &= RawEnum2 ())
+CHECK_VALID (false, void, re ^= RawEnum2 ())
+CHECK_VALID (true, RawEnum&, re |= RawEnum ())
+CHECK_VALID (true, RawEnum&, re &= RawEnum ())
+CHECK_VALID (true, RawEnum&, re ^= RawEnum ())
/* operator OP= (enum_flags, raw_enum), rvalue ref on the lhs. */
-CHECK_VALID (false, void, EF () |= RE2 ())
-CHECK_VALID (false, void, EF () &= RE2 ())
-CHECK_VALID (false, void, EF () ^= RE2 ())
-CHECK_VALID (false, void, EF () |= RE ())
-CHECK_VALID (false, void, EF () &= RE ())
-CHECK_VALID (false, void, EF () ^= RE ())
+CHECK_VALID (false, void, EnumFlag () |= RawEnum2 ())
+CHECK_VALID (false, void, EnumFlag () &= RawEnum2 ())
+CHECK_VALID (false, void, EnumFlag () ^= RawEnum2 ())
+CHECK_VALID (false, void, EnumFlag () |= RawEnum ())
+CHECK_VALID (false, void, EnumFlag () &= RawEnum ())
+CHECK_VALID (false, void, EnumFlag () ^= RawEnum ())
/* operator OP= (enum_flags, raw_enum), lvalue ref on the lhs. */
-CHECK_VALID (false, void, ef |= RE2 ())
-CHECK_VALID (false, void, ef &= RE2 ())
-CHECK_VALID (false, void, ef ^= RE2 ())
-CHECK_VALID (true, EF&, ef |= EF ())
-CHECK_VALID (true, EF&, ef &= EF ())
-CHECK_VALID (true, EF&, ef ^= EF ())
+CHECK_VALID (false, void, ef |= RawEnum2 ())
+CHECK_VALID (false, void, ef &= RawEnum2 ())
+CHECK_VALID (false, void, ef ^= RawEnum2 ())
+CHECK_VALID (true, EnumFlag&, ef |= EnumFlag ())
+CHECK_VALID (true, EnumFlag&, ef &= EnumFlag ())
+CHECK_VALID (true, EnumFlag&, ef ^= EnumFlag ())
/* operator OP= (enum_flags, enum_flags), rvalue ref on the lhs. */
-CHECK_VALID (false, void, EF () |= EF2 ())
-CHECK_VALID (false, void, EF () &= EF2 ())
-CHECK_VALID (false, void, EF () ^= EF2 ())
-CHECK_VALID (false, void, EF () |= EF ())
-CHECK_VALID (false, void, EF () &= EF ())
-CHECK_VALID (false, void, EF () ^= EF ())
+CHECK_VALID (false, void, EnumFlag () |= EnumFlag2 ())
+CHECK_VALID (false, void, EnumFlag () &= EnumFlag2 ())
+CHECK_VALID (false, void, EnumFlag () ^= EnumFlag2 ())
+CHECK_VALID (false, void, EnumFlag () |= EnumFlag ())
+CHECK_VALID (false, void, EnumFlag () &= EnumFlag ())
+CHECK_VALID (false, void, EnumFlag () ^= EnumFlag ())
/* operator OP= (enum_flags, enum_flags), lvalue ref on the lhs. */
-CHECK_VALID (false, void, ef |= EF2 ())
-CHECK_VALID (false, void, ef &= EF2 ())
-CHECK_VALID (false, void, ef ^= EF2 ())
-CHECK_VALID (true, EF&, ef |= EF ())
-CHECK_VALID (true, EF&, ef &= EF ())
-CHECK_VALID (true, EF&, ef ^= EF ())
+CHECK_VALID (false, void, ef |= EnumFlag2 ())
+CHECK_VALID (false, void, ef &= EnumFlag2 ())
+CHECK_VALID (false, void, ef ^= EnumFlag2 ())
+CHECK_VALID (true, EnumFlag&, ef |= EnumFlag ())
+CHECK_VALID (true, EnumFlag&, ef &= EnumFlag ())
+CHECK_VALID (true, EnumFlag&, ef ^= EnumFlag ())
/* operator~ (raw_enum) */
-CHECK_VALID (false, void, ~RE ())
-CHECK_VALID (true, URE, ~URE ())
+CHECK_VALID (false, void, ~RawEnum ())
+CHECK_VALID (true, UnsignedRawEnum, ~UnsignedRawEnum ())
/* operator~ (enum_flags) */
-CHECK_VALID (false, void, ~EF ())
-CHECK_VALID (true, UEF, ~UEF ())
+CHECK_VALID (false, void, ~EnumFlag ())
+CHECK_VALID (true, UnsignedEnumFlag, ~UnsignedEnumFlag ())
/* Check ternary operator. This exercises implicit conversions. */
-CHECK_VALID (true, EF, true ? EF () : RE ())
-CHECK_VALID (true, EF, true ? RE () : EF ())
-
-/* These are valid, but it's not a big deal since you won't be able to
- assign the resulting integer to an enum or an enum_flags without a
- cast.
-
- The latter two tests are disabled on older GCCs because they
- incorrectly fail with gcc 4.8 and 4.9 at least. Running the test
- outside a SFINAE context shows:
-
- invalid user-defined conversion from ‘EF’ to ‘RE2’
-
- They've been confirmed to compile/pass with gcc 5.3, gcc 7.1 and
- clang 3.7. */
-
-CHECK_VALID (true, int, true ? EF () : EF2 ())
-CHECK_VALID (true, int, true ? EF2 () : EF ())
-CHECK_VALID (true, int, true ? EF () : RE2 ())
-CHECK_VALID (true, int, true ? RE2 () : EF ())
-
-/* Same, but with an unsigned enum. */
-
-typedef unsigned int uns;
-
-CHECK_VALID (true, uns, true ? EF () : UEF ())
-CHECK_VALID (true, uns, true ? UEF () : EF ())
-CHECK_VALID (true, uns, true ? EF () : URE ())
-CHECK_VALID (true, uns, true ? URE () : EF ())
+CHECK_VALID (true, EnumFlag, true ? EnumFlag () : RawEnum ())
+CHECK_VALID (true, EnumFlag, true ? RawEnum () : EnumFlag ())
/* Unfortunately this can't work due to the way C++ computes the
return type of the ternary conditional operator. int isn't
@@ -270,39 +245,39 @@ CHECK_VALID (true, uns, true ? URE () : EF ())
error: operands to ?: have different types ‘enum_flags<RE>’ and ‘int’
Confirmed to work with gcc 4.9, 5.3 and clang 3.7.
*/
-CHECK_VALID (false, void, true ? EF () : 0)
-CHECK_VALID (false, void, true ? 0 : EF ())
+CHECK_VALID (false, void, true ? EnumFlag () : 0)
+CHECK_VALID (false, void, true ? 0 : EnumFlag ())
/* Check that the ++/--/<</>>/<<=/>>= operators are deleted. */
-CHECK_VALID (false, void, RE ()++)
-CHECK_VALID (false, void, ++RE ())
-CHECK_VALID (false, void, --RE ())
-CHECK_VALID (false, void, RE ()--)
+CHECK_VALID (false, void, RawEnum ()++)
+CHECK_VALID (false, void, ++RawEnum ())
+CHECK_VALID (false, void, --RawEnum ())
+CHECK_VALID (false, void, RawEnum ()--)
-CHECK_VALID (false, void, RE () << 1)
-CHECK_VALID (false, void, RE () >> 1)
-CHECK_VALID (false, void, EF () << 1)
-CHECK_VALID (false, void, EF () >> 1)
+CHECK_VALID (false, void, RawEnum () << 1)
+CHECK_VALID (false, void, RawEnum () >> 1)
+CHECK_VALID (false, void, EnumFlag () << 1)
+CHECK_VALID (false, void, EnumFlag () >> 1)
-CHECK_VALID (false, void, RE () <<= 1)
-CHECK_VALID (false, void, RE () >>= 1)
-CHECK_VALID (false, void, EF () <<= 1)
-CHECK_VALID (false, void, EF () >>= 1)
+CHECK_VALID (false, void, RawEnum () <<= 1)
+CHECK_VALID (false, void, RawEnum () >>= 1)
+CHECK_VALID (false, void, EnumFlag () <<= 1)
+CHECK_VALID (false, void, EnumFlag () >>= 1)
/* Test comparison operators. */
-CHECK_VALID (false, void, EF () == EF2 ())
-CHECK_VALID (false, void, EF () == RE2 ())
-CHECK_VALID (false, void, RE () == EF2 ())
+CHECK_VALID (false, void, EnumFlag () == EnumFlag2 ())
+CHECK_VALID (false, void, EnumFlag () == RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () == EnumFlag2 ())
-CHECK_VALID (true, bool, EF (RE (1)) == EF (RE (1)))
-CHECK_VALID (true, bool, EF (RE (1)) == RE (1))
-CHECK_VALID (true, bool, RE (1) == EF (RE (1)))
+CHECK_VALID (true, bool, EnumFlag (RawEnum (1)) == EnumFlag (RawEnum (1)))
+CHECK_VALID (true, bool, EnumFlag (RawEnum (1)) == RawEnum (1))
+CHECK_VALID (true, bool, RawEnum (1) == EnumFlag (RawEnum (1)))
-CHECK_VALID (false, void, EF () != EF2 ())
-CHECK_VALID (false, void, EF () != RE2 ())
-CHECK_VALID (false, void, RE () != EF2 ())
+CHECK_VALID (false, void, EnumFlag () != EnumFlag2 ())
+CHECK_VALID (false, void, EnumFlag () != RawEnum2 ())
+CHECK_VALID (false, void, RawEnum () != EnumFlag2 ())
/* Disable -Wenum-compare due to:
@@ -323,23 +298,23 @@ CHECK_VALID (false, void, RE () != EF2 ())
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wenum-compare"
#endif
-CHECK_VALID (true, bool, RE () == RE2 ())
-CHECK_VALID (true, bool, RE () != RE2 ())
+CHECK_VALID (true, bool, RawEnum () == RawEnum2 ())
+CHECK_VALID (true, bool, RawEnum () != RawEnum2 ())
#if defined __GNUC__
# pragma GCC diagnostic pop
#endif
-CHECK_VALID (true, bool, EF (RE (1)) != EF (RE (2)))
-CHECK_VALID (true, bool, EF (RE (1)) != RE (2))
-CHECK_VALID (true, bool, RE (1) != EF (RE (2)))
+CHECK_VALID (true, bool, EnumFlag (RawEnum (1)) != EnumFlag (RawEnum (2)))
+CHECK_VALID (true, bool, EnumFlag (RawEnum (1)) != RawEnum (2))
+CHECK_VALID (true, bool, RawEnum (1) != EnumFlag (RawEnum (2)))
-CHECK_VALID (true, bool, EF () == 0)
+CHECK_VALID (true, bool, EnumFlag () == 0)
/* Check we didn't disable/delete comparison between non-flags enums
and unrelated types by mistake. */
-CHECK_VALID (true, bool, NF (1) == NF (1))
-CHECK_VALID (true, bool, NF (1) == int (1))
-CHECK_VALID (true, bool, NF (1) == char (1))
+CHECK_VALID (true, bool, NonFlagsEnum (1) == NonFlagsEnum (1))
+CHECK_VALID (true, bool, NonFlagsEnum (1) == int (1))
+CHECK_VALID (true, bool, NonFlagsEnum (1) == char (1))
/* -------------------------------------------------------------------- */
@@ -632,10 +607,7 @@ self_test ()
} /* namespace enum_flags_tests */
} /* namespace selftests */
-void _initialize_enum_flags_selftests ();
-
-void
-_initialize_enum_flags_selftests ()
+INIT_GDB_FILE (enum_flags_selftests)
{
selftests::register_test ("enum-flags",
selftests::enum_flags_tests::self_test);
generated by cgit v1.1 at 2025-07-03 10:58:39 +0000