mfbt/tests/TestTypedEnum.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/Assertions.h"
   8 #include "mozilla/Attributes.h"
   9 #include "mozilla/TypedEnum.h"
  10 #include "mozilla/TypedEnumBits.h"
  11
  12 #include <stdint.h>
  13
  14 // A rough feature check for is_literal_type. Not very carefully checked.
  15 // Feel free to amend as needed.
  16 // We leave ANDROID out because it's using stlport which doesn't have std::is_literal_type.
  17 #if __cplusplus >= 201103L && !defined(ANDROID)
  18 #  if defined(__clang__)
  19      /*
  20       * Per Clang documentation, "Note that marketing version numbers should not
  21       * be used to check for language features, as different vendors use different
  22       * numbering schemes. Instead, use the feature checking macros."
  23       */
  24 #    ifndef __has_extension
  25 #      define __has_extension __has_feature /* compatibility, for older versions of clang */
  26 #    endif
  27 #    if __has_extension(is_literal) && __has_include(<type_traits>)
  28 #      define MOZ_HAVE_IS_LITERAL
  29 #    endif
  30 #  elif defined(__GNUC__)
  31 #    if defined(__GXX_EXPERIMENTAL_CXX0X__)
  32 #      if MOZ_GCC_VERSION_AT_LEAST(4, 6, 0)
  33 #        define MOZ_HAVE_IS_LITERAL
  34 #      endif
  35 #    endif
  36 #  elif defined(_MSC_VER)
  37 #    if _MSC_VER >= 1700
  38 #      define MOZ_HAVE_IS_LITERAL
  39 #    endif
  40 #  endif
  41 #endif
  42
  43 #if defined(MOZ_HAVE_IS_LITERAL) && defined(MOZ_HAVE_CXX11_CONSTEXPR)
  44 #include <type_traits>
  45 template<typename T>
  46 void
  47 RequireLiteralType()
  48 {
  49   static_assert(std::is_literal_type<T>::value, "Expected a literal type");
  50 }
  51 #else // not MOZ_HAVE_IS_LITERAL
  52 template<typename T>
  53 void
  54 RequireLiteralType()
  55 {
  56 }
  57 #endif
  58
  59 template<typename T>
  60 void
  61 RequireLiteralType(const T&)
  62 {
  63   RequireLiteralType<T>();
  64 }
  65
  66 MOZ_BEGIN_ENUM_CLASS(AutoEnum)
  67   A,
  68   B = -3,
  69   C
  70 MOZ_END_ENUM_CLASS(AutoEnum)
  71
  72 MOZ_BEGIN_ENUM_CLASS(CharEnum, char)
  73   A,
  74   B = 3,
  75   C
  76 MOZ_END_ENUM_CLASS(CharEnum)
  77
  78 MOZ_BEGIN_ENUM_CLASS(AutoEnumBitField)
  79   A = 0x10,
  80   B = 0x20,
  81   C
  82 MOZ_END_ENUM_CLASS(AutoEnumBitField)
  83
  84 MOZ_BEGIN_ENUM_CLASS(CharEnumBitField, char)
  85   A = 0x10,
  86   B,
  87   C = 0x40
  88 MOZ_END_ENUM_CLASS(CharEnumBitField)
  89
  90 struct Nested
  91 {
  92   MOZ_BEGIN_NESTED_ENUM_CLASS(AutoEnum)
  93     A,
  94     B,
  95     C = -1
  96   MOZ_END_NESTED_ENUM_CLASS(AutoEnum)
  97
  98   MOZ_BEGIN_NESTED_ENUM_CLASS(CharEnum, char)
  99     A = 4,
 100     B,
 101     C = 1
 102   MOZ_END_NESTED_ENUM_CLASS(CharEnum)
 103
 104   MOZ_BEGIN_NESTED_ENUM_CLASS(AutoEnumBitField)
 105     A,
 106     B = 0x20,
 107     C
 108   MOZ_END_NESTED_ENUM_CLASS(AutoEnumBitField)
 109
 110   MOZ_BEGIN_NESTED_ENUM_CLASS(CharEnumBitField, char)
 111     A = 1,
 112     B = 1,
 113     C = 1
 114   MOZ_END_NESTED_ENUM_CLASS(CharEnumBitField)
 115 };
 116
 117 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(AutoEnumBitField)
 118 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(CharEnumBitField)
 119 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Nested::AutoEnumBitField)
 120 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Nested::CharEnumBitField)
 121
 122 #define MAKE_STANDARD_BITFIELD_FOR_TYPE(IntType)                   \
 123   MOZ_BEGIN_ENUM_CLASS(BitFieldFor_##IntType, IntType)             \
 124     A = 1,                                                         \
 125     B = 2,                                                         \
 126     C = 4,                                                         \
 127   MOZ_END_ENUM_CLASS(BitFieldFor_##IntType)                        \
 128   MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(BitFieldFor_##IntType)
 129
 130 MAKE_STANDARD_BITFIELD_FOR_TYPE(int8_t)
 131 MAKE_STANDARD_BITFIELD_FOR_TYPE(uint8_t)
 132 MAKE_STANDARD_BITFIELD_FOR_TYPE(int16_t)
 133 MAKE_STANDARD_BITFIELD_FOR_TYPE(uint16_t)
 134 MAKE_STANDARD_BITFIELD_FOR_TYPE(int32_t)
 135 MAKE_STANDARD_BITFIELD_FOR_TYPE(uint32_t)
 136 MAKE_STANDARD_BITFIELD_FOR_TYPE(int64_t)
 137 MAKE_STANDARD_BITFIELD_FOR_TYPE(uint64_t)
 138 MAKE_STANDARD_BITFIELD_FOR_TYPE(char)
 139 typedef signed char signed_char;
 140 MAKE_STANDARD_BITFIELD_FOR_TYPE(signed_char)
 141 typedef unsigned char unsigned_char;
 142 MAKE_STANDARD_BITFIELD_FOR_TYPE(unsigned_char)
 143 MAKE_STANDARD_BITFIELD_FOR_TYPE(short)
 144 typedef unsigned short unsigned_short;
 145 MAKE_STANDARD_BITFIELD_FOR_TYPE(unsigned_short)
 146 MAKE_STANDARD_BITFIELD_FOR_TYPE(int)
 147 typedef unsigned int unsigned_int;
 148 MAKE_STANDARD_BITFIELD_FOR_TYPE(unsigned_int)
 149 MAKE_STANDARD_BITFIELD_FOR_TYPE(long)
 150 typedef unsigned long unsigned_long;
 151 MAKE_STANDARD_BITFIELD_FOR_TYPE(unsigned_long)
 152 typedef long long long_long;
 153 MAKE_STANDARD_BITFIELD_FOR_TYPE(long_long)
 154 typedef unsigned long long unsigned_long_long;
 155 MAKE_STANDARD_BITFIELD_FOR_TYPE(unsigned_long_long)
 156
 157 #undef MAKE_STANDARD_BITFIELD_FOR_TYPE
 158
 159 template<typename T>
 160 void
 161 TestNonConvertibilityForOneType()
 162 {
 163   using mozilla::IsConvertible;
 164
 165 #if defined(MOZ_HAVE_CXX11_STRONG_ENUMS) && defined(MOZ_HAVE_EXPLICIT_CONVERSION)
 166   static_assert(!IsConvertible<T, bool>::value, "should not be convertible");
 167   static_assert(!IsConvertible<T, int>::value, "should not be convertible");
 168   static_assert(!IsConvertible<T, uint64_t>::value, "should not be convertible");
 169 #endif
 170
 171   static_assert(!IsConvertible<bool, T>::value, "should not be convertible");
 172   static_assert(!IsConvertible<int, T>::value, "should not be convertible");
 173   static_assert(!IsConvertible<uint64_t, T>::value, "should not be convertible");
 174 }
 175
 176 template<typename TypedEnum>
 177 void
 178 TestTypedEnumBasics()
 179 {
 180   const TypedEnum a = TypedEnum::A;
 181   int unused = int(a);
 182   (void) unused;
 183   RequireLiteralType(TypedEnum::A);
 184   RequireLiteralType(a);
 185   TestNonConvertibilityForOneType<TypedEnum>();
 186 }
 187
 188 // Op wraps a bitwise binary operator, passed as a char template parameter,
 189 // and applies it to its arguments (aT1, aT2). For example,
 190 //
 191 //   Op<'|'>(aT1, aT2)
 192 //
 193 // is the same as
 194 //
 195 //   aT1 | aT2.
 196 //
 197 template<char o, typename T1, typename T2>
 198 auto Op(const T1& aT1, const T2& aT2)
 199   -> decltype(aT1 | aT2) // See the static_assert's below --- the return type
 200                          // depends solely on the operands type, not on the
 201                          // choice of operation.
 202 {
 203   using mozilla::IsSame;
 204   static_assert(IsSame<decltype(aT1 | aT2), decltype(aT1 & aT2)>::value,
 205                 "binary ops should have the same result type");
 206   static_assert(IsSame<decltype(aT1 | aT2), decltype(aT1 ^ aT2)>::value,
 207                 "binary ops should have the same result type");
 208
 209   static_assert(o == '|' ||
 210                 o == '&' ||
 211                 o == '^', "unexpected operator character");
 212
 213   return o == '|' ? aT1 | aT2
 214        : o == '&' ? aT1 & aT2
 215                   : aT1 ^ aT2;
 216 }
 217
 218 // OpAssign wraps a bitwise binary operator, passed as a char template
 219 // parameter, and applies the corresponding compound-assignment operator to its
 220 // arguments (aT1, aT2). For example,
 221 //
 222 //   OpAssign<'|'>(aT1, aT2)
 223 //
 224 // is the same as
 225 //
 226 //   aT1 |= aT2.
 227 //
 228 template<char o, typename T1, typename T2>
 229 T1& OpAssign(T1& aT1, const T2& aT2)
 230 {
 231   static_assert(o == '|' ||
 232                 o == '&' ||
 233                 o == '^', "unexpected operator character");
 234
 235   switch (o) {
 236     case '|': return aT1 |= aT2;
 237     case '&': return aT1 &= aT2;
 238     case '^': return aT1 ^= aT2;
 239     default: MOZ_CRASH();
 240   }
 241 }
 242
 243 // Tests a single binary bitwise operator, using a single set of three operands.
 244 // The operations tested are:
 245 //
 246 //   result = aT1 Op aT2;
 247 //   result Op= aT3;
 248 //
 249 // Where Op is the operator specified by the char template parameter 'o' and
 250 // can be any of '|', '&', '^'.
 251 //
 252 // Note that the operands aT1, aT2, aT3 are intentionally passed with free
 253 // types (separate template parameters for each) because their type may
 254 // actually be different from TypedEnum:
 255 //
 256 //   1) Their type could be CastableTypedEnumResult<TypedEnum> if they are
 257 //      the result of a bitwise operation themselves;
 258 //   2) In the non-c++11 legacy path, the type of enum values is also
 259 //      different from TypedEnum.
 260 //
 261 template<typename TypedEnum, char o, typename T1, typename T2, typename T3>
 262 void TestBinOp(const T1& aT1, const T2& aT2, const T3& aT3)
 263 {
 264   typedef typename mozilla::detail::UnsignedIntegerTypeForEnum<TypedEnum>::Type
 265           UnsignedIntegerType;
 266
 267   // Part 1:
 268   // Test the bitwise binary operator i.e.
 269   //   result = aT1 Op aT2;
 270   auto result = Op<o>(aT1, aT2);
 271
 272   typedef decltype(result) ResultType;
 273
 274   RequireLiteralType<ResultType>();
 275   TestNonConvertibilityForOneType<ResultType>();
 276
 277   UnsignedIntegerType unsignedIntegerResult =
 278     Op<o>(UnsignedIntegerType(aT1), UnsignedIntegerType(aT2));
 279
 280   MOZ_RELEASE_ASSERT(unsignedIntegerResult == UnsignedIntegerType(result));
 281   MOZ_RELEASE_ASSERT(TypedEnum(unsignedIntegerResult) == TypedEnum(result));
 282   MOZ_RELEASE_ASSERT((!unsignedIntegerResult) == (!result));
 283   MOZ_RELEASE_ASSERT((!!unsignedIntegerResult) == (!!result));
 284   MOZ_RELEASE_ASSERT(bool(unsignedIntegerResult) == bool(result));
 285
 286   // Part 2:
 287   // Test the compound-assignment operator, i.e.
 288   //   result Op= aT3;
 289   TypedEnum newResult = result;
 290   OpAssign<o>(newResult, aT3);
 291   UnsignedIntegerType unsignedIntegerNewResult = unsignedIntegerResult;
 292   OpAssign<o>(unsignedIntegerNewResult, UnsignedIntegerType(aT3));
 293   MOZ_RELEASE_ASSERT(TypedEnum(unsignedIntegerNewResult) == newResult);
 294
 295   // Part 3:
 296   // Test additional boolean operators that we unfortunately had to add to
 297   // CastableTypedEnumResult at some point to please some compiler,
 298   // even though bool convertibility should have been enough.
 299   MOZ_RELEASE_ASSERT(result == TypedEnum(result));
 300   MOZ_RELEASE_ASSERT(!(result != TypedEnum(result)));
 301   MOZ_RELEASE_ASSERT((result && true) == bool(result));
 302   MOZ_RELEASE_ASSERT((result && false) == false);
 303   MOZ_RELEASE_ASSERT((true && result) == bool(result));
 304   MOZ_RELEASE_ASSERT((false && result && false) == false);
 305   MOZ_RELEASE_ASSERT((result || false) == bool(result));
 306   MOZ_RELEASE_ASSERT((result || true) == true);
 307   MOZ_RELEASE_ASSERT((false || result) == bool(result));
 308   MOZ_RELEASE_ASSERT((true || result) == true);
 309 }
 310
 311 // Similar to TestBinOp but testing the unary ~ operator.
 312 template<typename TypedEnum, typename T>
 313 void TestTilde(const T& aT)
 314 {
 315   typedef typename mozilla::detail::UnsignedIntegerTypeForEnum<TypedEnum>::Type
 316           UnsignedIntegerType;
 317
 318   auto result = ~aT;
 319
 320   typedef decltype(result) ResultType;
 321
 322   RequireLiteralType<ResultType>();
 323   TestNonConvertibilityForOneType<ResultType>();
 324
 325   UnsignedIntegerType unsignedIntegerResult = ~(UnsignedIntegerType(aT));
 326
 327   MOZ_RELEASE_ASSERT(unsignedIntegerResult == UnsignedIntegerType(result));
 328   MOZ_RELEASE_ASSERT(TypedEnum(unsignedIntegerResult) == TypedEnum(result));
 329   MOZ_RELEASE_ASSERT((!unsignedIntegerResult) == (!result));
 330   MOZ_RELEASE_ASSERT((!!unsignedIntegerResult) == (!!result));
 331   MOZ_RELEASE_ASSERT(bool(unsignedIntegerResult) == bool(result));
 332 }
 333
 334 // Helper dispatching a given triple of operands to all operator-specific
 335 // testing functions.
 336 template<typename TypedEnum, typename T1, typename T2, typename T3>
 337 void TestAllOpsForGivenOperands(const T1& aT1, const T2& aT2, const T3& aT3)
 338 {
 339   TestBinOp<TypedEnum, '|'>(aT1, aT2, aT3);
 340   TestBinOp<TypedEnum, '&'>(aT1, aT2, aT3);
 341   TestBinOp<TypedEnum, '^'>(aT1, aT2, aT3);
 342   TestTilde<TypedEnum>(aT1);
 343 }
 344
 345 // Helper building various triples of operands using a given operator,
 346 // and testing all operators with them.
 347 template<typename TypedEnum, char o>
 348 void TestAllOpsForOperandsBuiltUsingGivenOp()
 349 {
 350   // The type of enum values like TypedEnum::A may be different from
 351   // TypedEnum. That is the case in the legacy non-C++11 path. We want to
 352   // ensure good test coverage even when these two types are distinct.
 353   // To that effect, we have both 'auto' typed variables, preserving the
 354   // original type of enum values, and 'plain' typed variables, that
 355   // are plain TypedEnum's.
 356
 357   const TypedEnum a_plain = TypedEnum::A;
 358   const TypedEnum b_plain = TypedEnum::B;
 359   const TypedEnum c_plain = TypedEnum::C;
 360
 361   auto a_auto = TypedEnum::A;
 362   auto b_auto = TypedEnum::B;
 363   auto c_auto = TypedEnum::C;
 364
 365   auto ab_plain = Op<o>(a_plain, b_plain);
 366   auto bc_plain = Op<o>(b_plain, c_plain);
 367   auto ab_auto = Op<o>(a_auto, b_auto);
 368   auto bc_auto = Op<o>(b_auto, c_auto);
 369
 370   // On each row below, we pass a triple of operands. Keep in mind that this
 371   // is going to be received as (aT1, aT2, aT3) and the actual tests performed
 372   // will be of the form
 373   //
 374   //   result = aT1 Op aT2;
 375   //   result Op= aT3;
 376   //
 377   // For this reason, we carefully ensure that the values of (aT1, aT2)
 378   // systematically cover all types of such pairs; to limit complexity,
 379   // we are not so careful with aT3, and we just try to pass aT3's
 380   // that may lead to nontrivial bitwise operations.
 381   TestAllOpsForGivenOperands<TypedEnum>(a_plain,  b_plain,  c_plain);
 382   TestAllOpsForGivenOperands<TypedEnum>(a_plain,  bc_plain, b_auto);
 383   TestAllOpsForGivenOperands<TypedEnum>(ab_plain, c_plain,  a_plain);
 384   TestAllOpsForGivenOperands<TypedEnum>(ab_plain, bc_plain, a_auto);
 385
 386   TestAllOpsForGivenOperands<TypedEnum>(a_plain,  b_auto,   c_plain);
 387   TestAllOpsForGivenOperands<TypedEnum>(a_plain,  bc_auto,  b_auto);
 388   TestAllOpsForGivenOperands<TypedEnum>(ab_plain, c_auto,   a_plain);
 389   TestAllOpsForGivenOperands<TypedEnum>(ab_plain, bc_auto,  a_auto);
 390
 391   TestAllOpsForGivenOperands<TypedEnum>(a_auto,   b_plain,  c_plain);
 392   TestAllOpsForGivenOperands<TypedEnum>(a_auto,   bc_plain, b_auto);
 393   TestAllOpsForGivenOperands<TypedEnum>(ab_auto,  c_plain,  a_plain);
 394   TestAllOpsForGivenOperands<TypedEnum>(ab_auto,  bc_plain, a_auto);
 395
 396   TestAllOpsForGivenOperands<TypedEnum>(a_auto,   b_auto,   c_plain);
 397   TestAllOpsForGivenOperands<TypedEnum>(a_auto,   bc_auto,  b_auto);
 398   TestAllOpsForGivenOperands<TypedEnum>(ab_auto,  c_auto,   a_plain);
 399   TestAllOpsForGivenOperands<TypedEnum>(ab_auto,  bc_auto,  a_auto);
 400 }
 401
 402 // Tests all bitwise operations on a given TypedEnum bitfield.
 403 template<typename TypedEnum>
 404 void
 405 TestTypedEnumBitField()
 406 {
 407   TestTypedEnumBasics<TypedEnum>();
 408
 409   TestAllOpsForOperandsBuiltUsingGivenOp<TypedEnum, '|'>();
 410   TestAllOpsForOperandsBuiltUsingGivenOp<TypedEnum, '&'>();
 411   TestAllOpsForOperandsBuiltUsingGivenOp<TypedEnum, '^'>();
 412 }
 413
 414 // Checks that enum bitwise expressions have the same non-convertibility
 415 // properties as c++11 enum classes do, i.e. not implicitly convertible to
 416 // anything (though *explicitly* convertible).
 417 void TestNoConversionsBetweenUnrelatedTypes()
 418 {
 419   using mozilla::IsConvertible;
 420
 421   // Two typed enum classes having the same underlying integer type, to ensure
 422   // that we would catch bugs accidentally allowing conversions in that case.
 423   typedef CharEnumBitField T1;
 424   typedef Nested::CharEnumBitField T2;
 425
 426   static_assert(!IsConvertible<T1, T2>::value,
 427                 "should not be convertible");
 428   static_assert(!IsConvertible<T1, decltype(T2::A)>::value,
 429                 "should not be convertible");
 430   static_assert(!IsConvertible<T1, decltype(T2::A | T2::B)>::value,
 431                 "should not be convertible");
 432
 433   static_assert(!IsConvertible<decltype(T1::A), T2>::value,
 434                 "should not be convertible");
 435   static_assert(!IsConvertible<decltype(T1::A), decltype(T2::A)>::value,
 436                 "should not be convertible");
 437   static_assert(!IsConvertible<decltype(T1::A), decltype(T2::A | T2::B)>::value,
 438                 "should not be convertible");
 439
 440   // The following are #ifdef MOZ_HAVE_EXPLICIT_CONVERSION because without
 441   // support for explicit conversion operators, we can't easily have these bad
 442   // conversions completely removed. They still do fail to compile in practice,
 443   // but not in a way that we can static_assert on.
 444 #ifdef MOZ_HAVE_EXPLICIT_CONVERSION
 445   static_assert(!IsConvertible<decltype(T1::A | T1::B), T2>::value,
 446                 "should not be convertible");
 447   static_assert(!IsConvertible<decltype(T1::A | T1::B), decltype(T2::A)>::value,
 448                 "should not be convertible");
 449   static_assert(!IsConvertible<decltype(T1::A | T1::B), decltype(T2::A | T2::B)>::value,
 450                 "should not be convertible");
 451 #endif
 452 }
 453
 454 MOZ_BEGIN_ENUM_CLASS(Int8EnumWithHighBits, int8_t)
 455   A = 0x20,
 456   B = 0x40
 457 MOZ_END_ENUM_CLASS(Int8EnumWithHighBits)
 458 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Int8EnumWithHighBits)
 459
 460 MOZ_BEGIN_ENUM_CLASS(Uint8EnumWithHighBits, uint8_t)
 461   A = 0x40,
 462   B = 0x80
 463 MOZ_END_ENUM_CLASS(Uint8EnumWithHighBits)
 464 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Uint8EnumWithHighBits)
 465
 466 MOZ_BEGIN_ENUM_CLASS(Int16EnumWithHighBits, int16_t)
 467   A = 0x2000,
 468   B = 0x4000
 469 MOZ_END_ENUM_CLASS(Int16EnumWithHighBits)
 470 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Int16EnumWithHighBits)
 471
 472 MOZ_BEGIN_ENUM_CLASS(Uint16EnumWithHighBits, uint16_t)
 473   A = 0x4000,
 474   B = 0x8000
 475 MOZ_END_ENUM_CLASS(Uint16EnumWithHighBits)
 476 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Uint16EnumWithHighBits)
 477
 478 MOZ_BEGIN_ENUM_CLASS(Int32EnumWithHighBits, int32_t)
 479   A = 0x20000000,
 480   B = 0x40000000
 481 MOZ_END_ENUM_CLASS(Int32EnumWithHighBits)
 482 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Int32EnumWithHighBits)
 483
 484 MOZ_BEGIN_ENUM_CLASS(Uint32EnumWithHighBits, uint32_t)
 485   A = 0x40000000u,
 486   B = 0x80000000u
 487 MOZ_END_ENUM_CLASS(Uint32EnumWithHighBits)
 488 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Uint32EnumWithHighBits)
 489
 490 MOZ_BEGIN_ENUM_CLASS(Int64EnumWithHighBits, int64_t)
 491   A = 0x2000000000000000ll,
 492   B = 0x4000000000000000ll
 493 MOZ_END_ENUM_CLASS(Int64EnumWithHighBits)
 494 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Int64EnumWithHighBits)
 495
 496 MOZ_BEGIN_ENUM_CLASS(Uint64EnumWithHighBits, uint64_t)
 497   A = 0x4000000000000000ull,
 498   B = 0x8000000000000000ull
 499 MOZ_END_ENUM_CLASS(Uint64EnumWithHighBits)
 500 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Uint64EnumWithHighBits)
 501
 502 // Checks that we don't accidentally truncate high bits by coercing to the wrong
 503 // integer type internally when implementing bitwise ops.
 504 template<typename EnumType, typename IntType>
 505 void TestIsNotTruncated()
 506 {
 507   EnumType a = EnumType::A;
 508   EnumType b = EnumType::B;
 509   MOZ_RELEASE_ASSERT(IntType(a));
 510   MOZ_RELEASE_ASSERT(IntType(b));
 511   MOZ_RELEASE_ASSERT(a | EnumType::B);
 512   MOZ_RELEASE_ASSERT(a | b);
 513   MOZ_RELEASE_ASSERT(EnumType::A | EnumType::B);
 514   EnumType c = EnumType::A | EnumType::B;
 515   MOZ_RELEASE_ASSERT(IntType(c));
 516   MOZ_RELEASE_ASSERT(c & c);
 517   MOZ_RELEASE_ASSERT(c | c);
 518   MOZ_RELEASE_ASSERT(c == (EnumType::A | EnumType::B));
 519   MOZ_RELEASE_ASSERT(a != (EnumType::A | EnumType::B));
 520   MOZ_RELEASE_ASSERT(b != (EnumType::A | EnumType::B));
 521   MOZ_RELEASE_ASSERT(c & EnumType::A);
 522   MOZ_RELEASE_ASSERT(c & EnumType::B);
 523   EnumType d = EnumType::A;
 524   d |= EnumType::B;
 525   MOZ_RELEASE_ASSERT(d == c);
 526 }
 527
 528 int
 529 main()
 530 {
 531   TestTypedEnumBasics<AutoEnum>();
 532   TestTypedEnumBasics<CharEnum>();
 533   TestTypedEnumBasics<Nested::AutoEnum>();
 534   TestTypedEnumBasics<Nested::CharEnum>();
 535
 536   TestTypedEnumBitField<AutoEnumBitField>();
 537   TestTypedEnumBitField<CharEnumBitField>();
 538   TestTypedEnumBitField<Nested::AutoEnumBitField>();
 539   TestTypedEnumBitField<Nested::CharEnumBitField>();
 540
 541   TestTypedEnumBitField<BitFieldFor_uint8_t>();
 542   TestTypedEnumBitField<BitFieldFor_int8_t>();
 543   TestTypedEnumBitField<BitFieldFor_uint16_t>();
 544   TestTypedEnumBitField<BitFieldFor_int16_t>();
 545   TestTypedEnumBitField<BitFieldFor_uint32_t>();
 546   TestTypedEnumBitField<BitFieldFor_int32_t>();
 547   TestTypedEnumBitField<BitFieldFor_uint64_t>();
 548   TestTypedEnumBitField<BitFieldFor_int64_t>();
 549   TestTypedEnumBitField<BitFieldFor_char>();
 550   TestTypedEnumBitField<BitFieldFor_signed_char>();
 551   TestTypedEnumBitField<BitFieldFor_unsigned_char>();
 552   TestTypedEnumBitField<BitFieldFor_short>();
 553   TestTypedEnumBitField<BitFieldFor_unsigned_short>();
 554   TestTypedEnumBitField<BitFieldFor_int>();
 555   TestTypedEnumBitField<BitFieldFor_unsigned_int>();
 556   TestTypedEnumBitField<BitFieldFor_long>();
 557   TestTypedEnumBitField<BitFieldFor_unsigned_long>();
 558   TestTypedEnumBitField<BitFieldFor_long_long>();
 559   TestTypedEnumBitField<BitFieldFor_unsigned_long_long>();
 560
 561   TestNoConversionsBetweenUnrelatedTypes();
 562
 563   TestIsNotTruncated<Int8EnumWithHighBits, int8_t>();
 564   TestIsNotTruncated<Int16EnumWithHighBits, int16_t>();
 565   TestIsNotTruncated<Int32EnumWithHighBits, int32_t>();
 566   TestIsNotTruncated<Int64EnumWithHighBits, int64_t>();
 567   TestIsNotTruncated<Uint8EnumWithHighBits, uint8_t>();
 568   TestIsNotTruncated<Uint16EnumWithHighBits, uint16_t>();
 569   TestIsNotTruncated<Uint32EnumWithHighBits, uint32_t>();
 570   TestIsNotTruncated<Uint64EnumWithHighBits, uint64_t>();
 571
 572   return 0;
 573 }