unittests/ADT/BitmaskEnumTest.cpp

   1 //===- llvm/unittest/ADT/BitmaskEnumTest.cpp - BitmaskEnum unit tests -----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/BitmaskEnum.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16 enum Flags {
  17   F0 = 0,
  18   F1 = 1,
  19   F2 = 2,
  20   F3 = 4,
  21   F4 = 8,
  22   LLVM_MARK_AS_BITMASK_ENUM(F4)
  23 };
  24
  25 TEST(BitmaskEnumTest, BitwiseOr) {
  26   Flags f = F1 | F2;
  27   EXPECT_EQ(3, f);
  28
  29   f = f | F3;
  30   EXPECT_EQ(7, f);
  31 }
  32
  33 TEST(BitmaskEnumTest, BitwiseOrEquals) {
  34   Flags f = F1;
  35   f |= F3;
  36   EXPECT_EQ(5, f);
  37
  38   // |= should return a reference to the LHS.
  39   f = F2;
  40   (f |= F3) = F1;
  41   EXPECT_EQ(F1, f);
  42 }
  43
  44 TEST(BitmaskEnumTest, BitwiseAnd) {
  45   Flags f = static_cast<Flags>(3) & F2;
  46   EXPECT_EQ(F2, f);
  47
  48   f = (f | F3) & (F1 | F2 | F3);
  49   EXPECT_EQ(6, f);
  50 }
  51
  52 TEST(BitmaskEnumTest, BitwiseAndEquals) {
  53   Flags f = F1 | F2 | F3;
  54   f &= F1 | F2;
  55   EXPECT_EQ(3, f);
  56
  57   // &= should return a reference to the LHS.
  58   (f &= F1) = F3;
  59   EXPECT_EQ(F3, f);
  60 }
  61
  62 TEST(BitmaskEnumTest, BitwiseXor) {
  63   Flags f = (F1 | F2) ^ (F2 | F3);
  64   EXPECT_EQ(5, f);
  65
  66   f = f ^ F1;
  67   EXPECT_EQ(4, f);
  68 }
  69
  70 TEST(BitmaskEnumTest, BitwiseXorEquals) {
  71   Flags f = (F1 | F2);
  72   f ^= (F2 | F4);
  73   EXPECT_EQ(9, f);
  74
  75   // ^= should return a reference to the LHS.
  76   (f ^= F4) = F3;
  77   EXPECT_EQ(F3, f);
  78 }
  79
  80 TEST(BitmaskEnumTest, BitwiseNot) {
  81   Flags f = ~F1;
  82   EXPECT_EQ(14, f); // Largest value for f is 15.
  83   EXPECT_EQ(15, ~F0);
  84 }
  85
  86 enum class FlagsClass {
  87   F0 = 0,
  88   F1 = 1,
  89   F2 = 2,
  90   F3 = 4,
  91   LLVM_MARK_AS_BITMASK_ENUM(F3)
  92 };
  93
  94 TEST(BitmaskEnumTest, ScopedEnum) {
  95   FlagsClass f = (FlagsClass::F1 & ~FlagsClass::F0) | FlagsClass::F2;
  96   f |= FlagsClass::F3;
  97   EXPECT_EQ(7, static_cast<int>(f));
  98 }
  99
 100 struct Container {
 101   enum Flags { F0 = 0, F1 = 1, F2 = 2, F3 = 4, LLVM_MARK_AS_BITMASK_ENUM(F3) };
 102
 103   static Flags getFlags() {
 104     Flags f = F0 | F1;
 105     f |= F2;
 106     return f;
 107   }
 108 };
 109
 110 TEST(BitmaskEnumTest, EnumInStruct) { EXPECT_EQ(3, Container::getFlags()); }
 111
 112 } // namespace
 113
 114 namespace foo {
 115 namespace bar {
 116 namespace {
 117 enum FlagsInNamespace {
 118   F0 = 0,
 119   F1 = 1,
 120   F2 = 2,
 121   F3 = 4,
 122   LLVM_MARK_AS_BITMASK_ENUM(F3)
 123 };
 124 } // namespace
 125 } // namespace foo
 126 } // namespace bar
 127
 128 namespace {
 129 TEST(BitmaskEnumTest, EnumInNamespace) {
 130   foo::bar::FlagsInNamespace f = ~foo::bar::F0 & (foo::bar::F1 | foo::bar::F2);
 131   f |= foo::bar::F3;
 132   EXPECT_EQ(7, f);
 133 }
 134 } // namespace