Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity
Files
140ba011c003fda0fb2f746cf2bc0f010bf4ac03
binutils-gdb/gdb/unittests/enum-flags-selftests.c
Carlos Galvez 4a0b2cb721 Fix -Wenum-constexpr-conversion in enum-flags.h 
This fixes PR 31331:
https://sourceware.org/bugzilla/show_bug.cgi?id=31331

Currently, enum-flags.h is suppressing the warning
-Wenum-constexpr-conversion coming from recent versions of Clang.
This warning is intended to be made a compiler error
(non-downgradeable) in future versions of Clang:

https://github.com/llvm/llvm-project/issues/59036

The rationale is that casting a value of an integral type into an
enumeration is Undefined Behavior if the value does not fit in the
range of values of the enum:
https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1766

Undefined Behavior is not allowed in constant expressions, leading to
an ill-formed program.

In this case, in enum-flags.h, we are casting the value -1 to an enum
of a positive range only, which is UB as per the Standard and thus not
allowed in a constexpr context.

The purpose of doing this instead of using std::underlying_type is
because, for C-style enums, std::underlying_type typically returns
"unsigned int". However, when operating with it arithmetically, the
enum is promoted to *signed* int, which is what we want to avoid.

This patch solves this issue as follows:

* Use std::underlying_type and remove the custom enum_underlying_type.

* Ensure that operator~ is called always on an unsigned integer. We do
  this by casting the input enum into std::size_t, which can fit any
  unsigned integer. We have the guarantee that the cast is safe,
  because we have checked that the underlying type is unsigned. If the
  enum had negative values, the underlying type would be signed.

  This solves the issue with C-style enums, but also solves a hidden
  issue: enums with underlying type of std::uint8_t or std::uint16_t are
  *also* promoted to signed int. Now they are all explicitly casted
  to the largest unsigned int type and operator~ is safe to use.

* There is one more thing that needs fix. Currently, operator~ is
  implemented as follows:

  return (enum_type) ~underlying(e);

  After applying ~underlying(e), the result is a very large value,
  which we then cast to "enum_type". This cast is Undefined Behavior
  if the large value does not fit in the range of the enum. For
  C++ enums (scoped and/or with explicit underlying type), the range
  of the enum is the entire range of the underlying type, so the cast
  is safe. However, for C-style enums, the range is the smallest
  bit-field that can hold all the values of the enumeration. So the
  range is a lot smaller and casting a large value to the enum would
  invoke Undefined Behavior.

  To solve this problem, we create a new trait
  EnumHasFixedUnderlyingType, to ensure operator~ may only be called
  on C++-style enums. This behavior is roughly the same as what we
  had on trunk, but relying on different properties of the enums.

* Once this is implemented, the following tests fail to compile:

  CHECK_VALID (true,  int,  true ? EF () : EF2 ())

  This is because it expects the enums to be promoted to signed int,
  instead of unsigned int (which is the true underlying type).

  I propose to remove these tests altogether, because:

  - The comment nearby say they are not very important.
  - Comparing 2 enums of different type like that is strange, relies
    on integer promotions and thus hurts readability. As per comments
    in the related PR, we likely don't want this type of code in gdb
    code anyway, so there's no point in testing it.
  - Most importantly, this type of comparison will be ill-formed in
    C++26 for regular enums, so enum_flags does not need to emulate
    that.

Since this is the only place where the warning was suppressed, remove
also the corresponding macro in include/diagnostics.h.

The change has been tested by running the entire gdb test suite
(make check) and comparing the results (testsuite/gdb.sum) against
trunk. No noticeable differences have been observed.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=31331
Tested-by: Keith Seitz <keiths@redhat.com>
Approved-By: Tom Tromey <tom@tromey.com>
2024-12-22 10:48:58 -07:00

618 lines
18 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Self tests for enum-flags for GDB, the GNU debugger.
Copyright (C) 2016-2024 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "gdbsupport/enum-flags.h"
#include "gdbsupport/valid-expr.h"
#include "gdbsupport/selftest.h"
namespace selftests {
namespace enum_flags_tests {
/* The (real) enum types used in CHECK_VALID. Their names match the
template parameter names of the templates defined by CHECK_VALID to
make it simpler to use. They could be named differently. */
/* A "real enum". */
enum RawEnum
{
RawEnum_Flag1 = 1 << 1,
RawEnum_Flag2 = 1 << 2,
};
/* Another "real enum". */
enum RawEnum2
{
RawEnum2_Flag1 = 1 << 1,
RawEnum2_Flag2 = 1 << 2,
};
/* An unsigned "real enum". */
enum UnsignedRawEnum : unsigned
{
UnsignedRawEnum_Flag1 = 1 << 1,
UnsignedRawEnum_Flag2 = 1 << 2,
UnsignedRawEnum_Flag3 = 0xffffffff,
};
/* A non-flags enum. */
enum NonFlagsEnum
{
NonFlagsEnum_Flag1 = 1 << 1,
NonFlagsEnum_Flag2 = 1 << 2,
};
/* The corresponding "enum flags" types. */
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<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 RawEnum re ATTRIBUTE_UNUSED;
static EnumFlag ef ATTRIBUTE_UNUSED;
/* First, compile-time tests that:
- make sure that incorrect operations with mismatching enum types
are caught at compile time.
- make sure that the same operations but involving the right enum
types do compile and that they return the correct type.
*/
#define CHECK_VALID(VALID, EXPR_TYPE, EXPR) \
CHECK_VALID_EXPR_6 (EnumFlag, RawEnum, EnumFlag2, RawEnum2, \
UnsignedEnumFlag, UnsignedRawEnum, VALID, EXPR_TYPE, \
EXPR)
using und = std::underlying_type<RawEnum>::type;
/* Test construction / conversion from/to different types. */
/* RE/EF -> underlying (explicit) */
CHECK_VALID (true, und, und (RawEnum ()))
CHECK_VALID (true, und, und (EnumFlag ()))
/* RE/EF -> int (explicit) */
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, 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. */
/* As expected, enum-flags is a stronger type than the backing raw
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, 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, RawEnum () | 1)
CHECK_VALID (false, void, RawEnum () & 1)
CHECK_VALID (false, void, RawEnum () ^ 1)
/* operator OP (int, raw_enum) */
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, EnumFlag () | 1)
CHECK_VALID (false, void, EnumFlag () & 1)
CHECK_VALID (false, void, EnumFlag () ^ 1)
/* operator OP (int, enum_flags) */
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, 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, 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, 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 |= 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, 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 |= 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, 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 |= 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, ~RawEnum ())
CHECK_VALID (true, UnsignedRawEnum, ~UnsignedRawEnum ())
/* operator~ (enum_flags) */
CHECK_VALID (false, void, ~EnumFlag ())
CHECK_VALID (true, UnsignedEnumFlag, ~UnsignedEnumFlag ())
/* Check ternary operator. This exercises implicit conversions. */
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
implicitly convertible to the raw enum type, so the type of the
expression is int. And then int is not implicitly convertible to
enum_flags.
GCC 4.8 fails to compile this test with:
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 ? EnumFlag () : 0)
CHECK_VALID (false, void, true ? 0 : EnumFlag ())
/* Check that the ++/--/<</>>/<<=/>>= operators are deleted. */
CHECK_VALID (false, void, RawEnum ()++)
CHECK_VALID (false, void, ++RawEnum ())
CHECK_VALID (false, void, --RawEnum ())
CHECK_VALID (false, void, RawEnum ()--)
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, 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, EnumFlag () == EnumFlag2 ())
CHECK_VALID (false, void, EnumFlag () == RawEnum2 ())
CHECK_VALID (false, void, RawEnum () == EnumFlag2 ())
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, EnumFlag () != EnumFlag2 ())
CHECK_VALID (false, void, EnumFlag () != RawEnum2 ())
CHECK_VALID (false, void, RawEnum () != EnumFlag2 ())
/* Disable -Wenum-compare due to:
Clang:
"error: comparison of two values with different enumeration types
[-Werror,-Wenum-compare]"
GCC:
"error: comparison between ‘enum selftests::enum_flags_tests::RE’
and ‘enum selftests::enum_flags_tests::RE2’
[-Werror=enum-compare]"
Not a big deal since misuses like these in GDB will be caught by
-Werror anyway. This check is here mainly for completeness. */
#if defined __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wenum-compare"
#endif
CHECK_VALID (true, bool, RawEnum () == RawEnum2 ())
CHECK_VALID (true, bool, RawEnum () != RawEnum2 ())
#if defined __GNUC__
# pragma GCC diagnostic pop
#endif
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, EnumFlag () == 0)
/* Check we didn't disable/delete comparison between non-flags enums
and unrelated types by mistake. */
CHECK_VALID (true, bool, NonFlagsEnum (1) == NonFlagsEnum (1))
CHECK_VALID (true, bool, NonFlagsEnum (1) == int (1))
CHECK_VALID (true, bool, NonFlagsEnum (1) == char (1))
/* -------------------------------------------------------------------- */
/* Follows misc tests that exercise the API. Some are compile time,
when possible, others are run time. */
enum test_flag
{
FLAG1 = 1 << 0,
FLAG2 = 1 << 1,
FLAG3 = 1 << 2,
FLAG4 = 1 << 3,
};
enum test_uflag : unsigned
{
UFLAG1 = 1 << 0,
UFLAG2 = 1 << 1,
UFLAG3 = 1 << 2,
UFLAG4 = 1 << 3,
};
DEF_ENUM_FLAGS_TYPE (test_flag, test_flags);
DEF_ENUM_FLAGS_TYPE (test_uflag, test_uflags);
/* to_string enumerator->string mapping functions used to test
enum_flags::to_string. These intentionally miss mapping a couple
enumerators each (xFLAG2, xFLAG4). */
static std::string
to_string_flags (test_flags flags)
{
static constexpr test_flags::string_mapping mapping[] = {
MAP_ENUM_FLAG (FLAG1),
MAP_ENUM_FLAG (FLAG3),
};
return flags.to_string (mapping);
}
static std::string
to_string_uflags (test_uflags flags)
{
static constexpr test_uflags::string_mapping mapping[] = {
MAP_ENUM_FLAG (UFLAG1),
MAP_ENUM_FLAG (UFLAG3),
};
return flags.to_string (mapping);
}
static void
self_test ()
{
/* Check that default construction works. */
{
constexpr test_flags f;
static_assert (f == 0);
}
/* Check that assignment from zero works. */
{
test_flags f (FLAG1);
SELF_CHECK (f == FLAG1);
f = 0;
SELF_CHECK (f == 0);
}
/* Check that construction from zero works. */
{
constexpr test_flags zero1 = 0;
constexpr test_flags zero2 (0);
constexpr test_flags zero3 {0};
constexpr test_flags zero4 = {0};
static_assert (zero1 == 0);
static_assert (zero2 == 0);
static_assert (zero3 == 0);
static_assert (zero4 == 0);
}
/* Check construction from enum value. */
{
static_assert (test_flags (FLAG1) == FLAG1);
static_assert (test_flags (FLAG2) != FLAG1);
}
/* Check copy/assignment. */
{
constexpr test_flags src = FLAG1;
constexpr test_flags f1 = src;
constexpr test_flags f2 (src);
constexpr test_flags f3 {src};
constexpr test_flags f4 = {src};
static_assert (f1 == FLAG1);
static_assert (f2 == FLAG1);
static_assert (f3 == FLAG1);
static_assert (f4 == FLAG1);
}
/* Check moving. */
{
test_flags src = FLAG1;
test_flags dst = 0;
dst = std::move (src);
SELF_CHECK (dst == FLAG1);
}
/* Check construction from an 'or' of multiple bits. For this to
work, operator| must be overridden to return an enum type. The
builtin version would return int instead and then the conversion
to test_flags would fail. */
{
constexpr test_flags f = FLAG1 | FLAG2;
static_assert (f == (FLAG1 | FLAG2));
}
/* Similarly, check that "FLAG1 | FLAG2" on the rhs of an assignment
operator works. */
{
test_flags f = 0;
f |= FLAG1 | FLAG2;
SELF_CHECK (f == (FLAG1 | FLAG2));
f &= FLAG1 | FLAG2;
SELF_CHECK (f == (FLAG1 | FLAG2));
f ^= FLAG1 | FLAG2;
SELF_CHECK (f == 0);
}
/* Check explicit conversion to int works. */
{
constexpr int some_bits (FLAG1 | FLAG2);
/* And comparison with int works too. */
static_assert (some_bits == (FLAG1 | FLAG2));
static_assert (some_bits == test_flags (FLAG1 | FLAG2));
}
/* Check operator| and operator|=. Particularly interesting is
making sure that putting the enum value on the lhs side of the
expression works (FLAG | f). */
{
test_flags f = FLAG1;
f |= FLAG2;
SELF_CHECK (f == (FLAG1 | FLAG2));
}
{
test_flags f = FLAG1;
f = f | FLAG2;
SELF_CHECK (f == (FLAG1 | FLAG2));
}
{
test_flags f = FLAG1;
f = FLAG2 | f;
SELF_CHECK (f == (FLAG1 | FLAG2));
}
/* Check the &/&= operators. */
{
test_flags f = FLAG1 & FLAG2;
SELF_CHECK (f == 0);
f = FLAG1 | FLAG2;
f &= FLAG2;
SELF_CHECK (f == FLAG2);
f = FLAG1 | FLAG2;
f = f & FLAG2;
SELF_CHECK (f == FLAG2);
f = FLAG1 | FLAG2;
f = FLAG2 & f;
SELF_CHECK (f == FLAG2);
}
/* Check the ^/^= operators. */
{
constexpr test_flags f = FLAG1 ^ FLAG2;
static_assert (f == (FLAG1 ^ FLAG2));
}
{
test_flags f = FLAG1 ^ FLAG2;
f ^= FLAG3;
SELF_CHECK (f == (FLAG1 | FLAG2 | FLAG3));
f = f ^ FLAG3;
SELF_CHECK (f == (FLAG1 | FLAG2));
f = FLAG3 ^ f;
SELF_CHECK (f == (FLAG1 | FLAG2 | FLAG3));
}
/* Check operator~. Note this only compiles with unsigned
flags. */
{
constexpr test_uflags f1 = ~UFLAG1;
constexpr test_uflags f2 = ~f1;
static_assert (f2 == UFLAG1);
}
/* Check the ternary operator. */
{
/* raw enum, raw enum */
constexpr test_flags f1 = true ? FLAG1 : FLAG2;
static_assert (f1 == FLAG1);
constexpr test_flags f2 = false ? FLAG1 : FLAG2;
static_assert (f2 == FLAG2);
}
{
/* enum flags, raw enum */
constexpr test_flags src = FLAG1;
constexpr test_flags f1 = true ? src : FLAG2;
static_assert (f1 == FLAG1);
constexpr test_flags f2 = false ? src : FLAG2;
static_assert (f2 == FLAG2);
}
{
/* enum flags, enum flags */
constexpr test_flags src1 = FLAG1;
constexpr test_flags src2 = FLAG2;
constexpr test_flags f1 = true ? src1 : src2;
static_assert (f1 == src1);
constexpr test_flags f2 = false ? src1 : src2;
static_assert (f2 == src2);
}
/* Check that we can use flags in switch expressions (requires
unambiguous conversion to integer). Also check that we can use
operator| in switch cases, where only constants are allowed.
This should work because operator| is constexpr. */
{
test_flags f = FLAG1 | FLAG2;
bool ok = false;
switch (f)
{
case FLAG1:
break;
case FLAG2:
break;
case FLAG1 | FLAG2:
ok = true;
break;
}
SELF_CHECK (ok);
}
/* Check string conversion. */
{
SELF_CHECK (to_string_uflags (0)
== "0x0 []");
SELF_CHECK (to_string_uflags (UFLAG1)
== "0x1 [UFLAG1]");
SELF_CHECK (to_string_uflags (UFLAG1 | UFLAG3)
== "0x5 [UFLAG1 UFLAG3]");
SELF_CHECK (to_string_uflags (UFLAG1 | UFLAG2 | UFLAG3)
== "0x7 [UFLAG1 UFLAG3 0x2]");
SELF_CHECK (to_string_uflags (UFLAG2)
== "0x2 [0x2]");
/* Check that even with multiple unmapped flags, we only print one
unmapped hex number (0xa, in this case). */
SELF_CHECK (to_string_uflags (UFLAG1 | UFLAG2 | UFLAG3 | UFLAG4)
== "0xf [UFLAG1 UFLAG3 0xa]");
SELF_CHECK (to_string_flags (0)
== "0x0 []");
SELF_CHECK (to_string_flags (FLAG1)
== "0x1 [FLAG1]");
SELF_CHECK (to_string_flags (FLAG1 | FLAG3)
== "0x5 [FLAG1 FLAG3]");
SELF_CHECK (to_string_flags (FLAG1 | FLAG2 | FLAG3)
== "0x7 [FLAG1 FLAG3 0x2]");
SELF_CHECK (to_string_flags (FLAG2)
== "0x2 [0x2]");
SELF_CHECK (to_string_flags (FLAG1 | FLAG2 | FLAG3 | FLAG4)
== "0xf [FLAG1 FLAG3 0xa]");
}
}
} /* namespace enum_flags_tests */
} /* namespace selftests */
void _initialize_enum_flags_selftests ();
void
_initialize_enum_flags_selftests ()
{
selftests::register_test ("enum-flags",
selftests::enum_flags_tests::self_test);
}
View Git Blame Copy Permalink