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