1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18 #include <input/Flags.h>
19
20 #include <type_traits>
21
22 namespace android::test {
23
24 using namespace android::flag_operators;
25
26 enum class TestFlags { ONE = 0x1, TWO = 0x2, THREE = 0x4 };
27
TEST(Flags,Test)28 TEST(Flags, Test) {
29 Flags<TestFlags> flags = TestFlags::ONE;
30 ASSERT_TRUE(flags.test(TestFlags::ONE));
31 ASSERT_FALSE(flags.test(TestFlags::TWO));
32 ASSERT_FALSE(flags.test(TestFlags::THREE));
33 }
34
TEST(Flags,Any)35 TEST(Flags, Any) {
36 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
37 ASSERT_TRUE(flags.any(TestFlags::ONE));
38 ASSERT_TRUE(flags.any(TestFlags::TWO));
39 ASSERT_FALSE(flags.any(TestFlags::THREE));
40 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::TWO));
41 ASSERT_TRUE(flags.any(TestFlags::TWO | TestFlags::THREE));
42 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::THREE));
43 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
44 }
45
TEST(Flags,All)46 TEST(Flags, All) {
47 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
48 ASSERT_TRUE(flags.all(TestFlags::ONE));
49 ASSERT_TRUE(flags.all(TestFlags::TWO));
50 ASSERT_FALSE(flags.all(TestFlags::THREE));
51 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::TWO));
52 ASSERT_FALSE(flags.all(TestFlags::TWO | TestFlags::THREE));
53 ASSERT_FALSE(flags.all(TestFlags::ONE | TestFlags::THREE));
54 ASSERT_FALSE(flags.all(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
55 }
56
TEST(Flags,DefaultConstructor_hasNoFlagsSet)57 TEST(Flags, DefaultConstructor_hasNoFlagsSet) {
58 Flags<TestFlags> flags;
59 ASSERT_FALSE(flags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
60 }
61
TEST(Flags,NotOperator_onEmptyFlagsSetsAllFlags)62 TEST(Flags, NotOperator_onEmptyFlagsSetsAllFlags) {
63 Flags<TestFlags> flags;
64 flags = ~flags;
65 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
66 }
67
TEST(Flags,NotOperator_onNonEmptyFlagsInvertsFlags)68 TEST(Flags, NotOperator_onNonEmptyFlagsInvertsFlags) {
69 Flags<TestFlags> flags = TestFlags::TWO;
70 flags = ~flags;
71 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::THREE));
72 ASSERT_FALSE(flags.test(TestFlags::TWO));
73 }
74
TEST(Flags,OrOperator_withNewFlag)75 TEST(Flags, OrOperator_withNewFlag) {
76 Flags<TestFlags> flags = TestFlags::ONE;
77 Flags<TestFlags> flags2 = flags | TestFlags::TWO;
78 ASSERT_FALSE(flags2.test(TestFlags::THREE));
79 ASSERT_TRUE(flags2.all(TestFlags::ONE | TestFlags::TWO));
80 }
81
TEST(Flags,OrOperator_withExistingFlag)82 TEST(Flags, OrOperator_withExistingFlag) {
83 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
84 Flags<TestFlags> flags2 = flags | TestFlags::THREE;
85 ASSERT_FALSE(flags2.test(TestFlags::TWO));
86 ASSERT_TRUE(flags2.all(TestFlags::ONE | TestFlags::THREE));
87 }
88
TEST(Flags,OrEqualsOperator_withNewFlag)89 TEST(Flags, OrEqualsOperator_withNewFlag) {
90 Flags<TestFlags> flags;
91 flags |= TestFlags::THREE;
92 ASSERT_TRUE(flags.test(TestFlags::THREE));
93 ASSERT_FALSE(flags.any(TestFlags::ONE | TestFlags::TWO));
94 }
95
TEST(Flags,OrEqualsOperator_withExistingFlag)96 TEST(Flags, OrEqualsOperator_withExistingFlag) {
97 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
98 flags |= TestFlags::THREE;
99 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::THREE));
100 ASSERT_FALSE(flags.test(TestFlags::TWO));
101 }
102
TEST(Flags,AndOperator_withOneSetFlag)103 TEST(Flags, AndOperator_withOneSetFlag) {
104 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
105 Flags<TestFlags> andFlags = flags & TestFlags::THREE;
106 ASSERT_TRUE(andFlags.test(TestFlags::THREE));
107 ASSERT_FALSE(andFlags.any(TestFlags::ONE | TestFlags::TWO));
108 }
109
TEST(Flags,AndOperator_withMultipleSetFlags)110 TEST(Flags, AndOperator_withMultipleSetFlags) {
111 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
112 Flags<TestFlags> andFlags = flags & (TestFlags::ONE | TestFlags::THREE);
113 ASSERT_TRUE(andFlags.all(TestFlags::ONE | TestFlags::THREE));
114 ASSERT_FALSE(andFlags.test(TestFlags::TWO));
115 }
116
TEST(Flags,AndOperator_withNoSetFlags)117 TEST(Flags, AndOperator_withNoSetFlags) {
118 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
119 Flags<TestFlags> andFlags = flags & TestFlags::TWO;
120 ASSERT_FALSE(andFlags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
121 }
122
TEST(Flags,Equality)123 TEST(Flags, Equality) {
124 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
125 Flags<TestFlags> flags2 = TestFlags::ONE | TestFlags::TWO;
126 ASSERT_EQ(flags1, flags2);
127 }
128
TEST(Flags,Inequality)129 TEST(Flags, Inequality) {
130 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
131 Flags<TestFlags> flags2 = TestFlags::ONE | TestFlags::THREE;
132 ASSERT_NE(flags1, flags2);
133 }
134
TEST(Flags,EqualsOperator)135 TEST(Flags, EqualsOperator) {
136 Flags<TestFlags> flags;
137 flags = TestFlags::ONE;
138 ASSERT_TRUE(flags.test(TestFlags::ONE));
139 ASSERT_FALSE(flags.any(TestFlags::TWO | TestFlags::THREE));
140 }
141
TEST(Flags,EqualsOperator_DontShareState)142 TEST(Flags, EqualsOperator_DontShareState) {
143 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
144 Flags<TestFlags> flags2 = flags1;
145 ASSERT_EQ(flags1, flags2);
146
147 flags1 &= TestFlags::TWO;
148 ASSERT_NE(flags1, flags2);
149 }
150
TEST(Flags,GetValue)151 TEST(Flags, GetValue) {
152 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
153 ASSERT_EQ(flags.get(), 0x3);
154 }
155
TEST(Flags,String_NoFlags)156 TEST(Flags, String_NoFlags) {
157 Flags<TestFlags> flags;
158 ASSERT_EQ(flags.string(), "0x0");
159 }
160
TEST(Flags,String_KnownValues)161 TEST(Flags, String_KnownValues) {
162 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
163 ASSERT_EQ(flags.string(), "ONE | TWO");
164 }
165
TEST(Flags,String_UnknownValues)166 TEST(Flags, String_UnknownValues) {
167 auto flags = Flags<TestFlags>(0b1011);
168 ASSERT_EQ(flags.string(), "ONE | TWO | 0x00000008");
169 }
170
TEST(FlagsIterator,IteratesOverAllFlags)171 TEST(FlagsIterator, IteratesOverAllFlags) {
172 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
173 Flags<TestFlags> flags2;
174 for (TestFlags f : flags1) {
175 flags2 |= f;
176 }
177 ASSERT_EQ(flags2, flags1);
178 }
179
TEST(FlagsIterator,IteratesInExpectedOrder)180 TEST(FlagsIterator, IteratesInExpectedOrder) {
181 const std::vector<TestFlags> flagOrder = {TestFlags::ONE, TestFlags::TWO};
182 Flags<TestFlags> flags;
183 for (TestFlags f : flagOrder) {
184 flags |= f;
185 }
186
187 size_t idx = 0;
188 auto iter = flags.begin();
189 while (iter != flags.end() && idx < flagOrder.size()) {
190 // Make sure the order is what we expect
191 ASSERT_EQ(*iter, flagOrder[idx]);
192 iter++;
193 idx++;
194 }
195 ASSERT_EQ(iter, flags.end());
196 }
TEST(FlagsIterator,PostFixIncrement)197 TEST(FlagsIterator, PostFixIncrement) {
198 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
199 auto iter = flags.begin();
200 ASSERT_EQ(*(iter++), TestFlags::ONE);
201 ASSERT_EQ(*iter, TestFlags::TWO);
202 ASSERT_EQ(*(iter++), TestFlags::TWO);
203 ASSERT_EQ(iter, flags.end());
204 }
205
TEST(FlagsIterator,PreFixIncrement)206 TEST(FlagsIterator, PreFixIncrement) {
207 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
208 auto iter = flags.begin();
209 ASSERT_EQ(*++iter, TestFlags::TWO);
210 ASSERT_EQ(++iter, flags.end());
211 }
212
TEST(FlagNames,RuntimeFlagName)213 TEST(FlagNames, RuntimeFlagName) {
214 TestFlags f = TestFlags::ONE;
215 ASSERT_EQ(flag_name(f), "ONE");
216 }
217
TEST(FlagNames,RuntimeUnknownFlagName)218 TEST(FlagNames, RuntimeUnknownFlagName) {
219 TestFlags f = static_cast<TestFlags>(0x8);
220 ASSERT_EQ(flag_name(f), std::nullopt);
221 }
222
TEST(FlagNames,CompileTimeFlagName)223 TEST(FlagNames, CompileTimeFlagName) {
224 static_assert(flag_name<TestFlags::TWO>() == "TWO");
225 }
226
227 } // namespace android::test