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 <ftl/flags.h>
18 #include <gtest/gtest.h>
19
20 #include <initializer_list>
21
22 namespace android::test {
23
24 using ftl::Flags;
25 using namespace ftl::flag_operators;
26
27 enum class TestFlags : uint8_t { ONE = 0x1, TWO = 0x2, THREE = 0x4 };
28
TEST(Flags,Test)29 TEST(Flags, Test) {
30 Flags<TestFlags> flags = TestFlags::ONE;
31 ASSERT_TRUE(flags.test(TestFlags::ONE));
32 ASSERT_FALSE(flags.test(TestFlags::TWO));
33 ASSERT_FALSE(flags.test(TestFlags::THREE));
34 }
35
TEST(Flags,Any)36 TEST(Flags, Any) {
37 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
38 ASSERT_TRUE(flags.any());
39 ASSERT_TRUE(flags.any(TestFlags::ONE));
40 ASSERT_TRUE(flags.any(TestFlags::TWO));
41 ASSERT_FALSE(flags.any(TestFlags::THREE));
42 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::TWO));
43 ASSERT_TRUE(flags.any(TestFlags::TWO | TestFlags::THREE));
44 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::THREE));
45 ASSERT_TRUE(flags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
46
47 Flags<TestFlags> emptyFlags;
48 ASSERT_FALSE(emptyFlags.any());
49 }
50
TEST(Flags,All)51 TEST(Flags, All) {
52 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
53 ASSERT_TRUE(flags.all(TestFlags::ONE));
54 ASSERT_TRUE(flags.all(TestFlags::TWO));
55 ASSERT_FALSE(flags.all(TestFlags::THREE));
56 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::TWO));
57 ASSERT_FALSE(flags.all(TestFlags::TWO | TestFlags::THREE));
58 ASSERT_FALSE(flags.all(TestFlags::ONE | TestFlags::THREE));
59 ASSERT_FALSE(flags.all(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
60 }
61
TEST(Flags,ImplicitConstructionAndAssignmentFromInitializerList)62 TEST(Flags, ImplicitConstructionAndAssignmentFromInitializerList) {
63 Flags<TestFlags> flags = {TestFlags::ONE, TestFlags::THREE};
64 ASSERT_TRUE(flags.test(TestFlags::ONE));
65 ASSERT_FALSE(flags.test(TestFlags::TWO));
66 ASSERT_TRUE(flags.test(TestFlags::THREE));
67
68 flags = {};
69 ASSERT_FALSE(flags.test(TestFlags::ONE));
70 ASSERT_FALSE(flags.test(TestFlags::TWO));
71 ASSERT_FALSE(flags.test(TestFlags::THREE));
72 }
73
TEST(Flags,DefaultConstructor_hasNoFlagsSet)74 TEST(Flags, DefaultConstructor_hasNoFlagsSet) {
75 Flags<TestFlags> flags;
76 ASSERT_FALSE(flags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
77 }
78
TEST(Flags,NotOperator_onEmptyFlagsSetsAllFlags)79 TEST(Flags, NotOperator_onEmptyFlagsSetsAllFlags) {
80 Flags<TestFlags> flags;
81 flags = ~flags;
82 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
83 }
84
TEST(Flags,NotOperator_onNonEmptyFlagsInvertsFlags)85 TEST(Flags, NotOperator_onNonEmptyFlagsInvertsFlags) {
86 Flags<TestFlags> flags = TestFlags::TWO;
87 flags = ~flags;
88 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::THREE));
89 ASSERT_FALSE(flags.test(TestFlags::TWO));
90 }
91
TEST(Flags,OrOperator_withNewFlag)92 TEST(Flags, OrOperator_withNewFlag) {
93 Flags<TestFlags> flags = TestFlags::ONE;
94 Flags<TestFlags> flags2 = flags | TestFlags::TWO;
95 ASSERT_FALSE(flags2.test(TestFlags::THREE));
96 ASSERT_TRUE(flags2.all(TestFlags::ONE | TestFlags::TWO));
97 }
98
TEST(Flags,OrOperator_withExistingFlag)99 TEST(Flags, OrOperator_withExistingFlag) {
100 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
101 Flags<TestFlags> flags2 = flags | TestFlags::THREE;
102 ASSERT_FALSE(flags2.test(TestFlags::TWO));
103 ASSERT_TRUE(flags2.all(TestFlags::ONE | TestFlags::THREE));
104 }
105
TEST(Flags,OrEqualsOperator_withNewFlag)106 TEST(Flags, OrEqualsOperator_withNewFlag) {
107 Flags<TestFlags> flags;
108 flags |= TestFlags::THREE;
109 ASSERT_TRUE(flags.test(TestFlags::THREE));
110 ASSERT_FALSE(flags.any(TestFlags::ONE | TestFlags::TWO));
111 }
112
TEST(Flags,OrEqualsOperator_withExistingFlag)113 TEST(Flags, OrEqualsOperator_withExistingFlag) {
114 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
115 flags |= TestFlags::THREE;
116 ASSERT_TRUE(flags.all(TestFlags::ONE | TestFlags::THREE));
117 ASSERT_FALSE(flags.test(TestFlags::TWO));
118 }
119
TEST(Flags,AndOperator_withOneSetFlag)120 TEST(Flags, AndOperator_withOneSetFlag) {
121 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
122 Flags<TestFlags> andFlags = flags & TestFlags::THREE;
123 ASSERT_TRUE(andFlags.test(TestFlags::THREE));
124 ASSERT_FALSE(andFlags.any(TestFlags::ONE | TestFlags::TWO));
125 }
126
TEST(Flags,AndOperator_withMultipleSetFlags)127 TEST(Flags, AndOperator_withMultipleSetFlags) {
128 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
129 Flags<TestFlags> andFlags = flags & (TestFlags::ONE | TestFlags::THREE);
130 ASSERT_TRUE(andFlags.all(TestFlags::ONE | TestFlags::THREE));
131 ASSERT_FALSE(andFlags.test(TestFlags::TWO));
132 }
133
TEST(Flags,AndOperator_withNoSetFlags)134 TEST(Flags, AndOperator_withNoSetFlags) {
135 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::THREE;
136 Flags<TestFlags> andFlags = flags & TestFlags::TWO;
137 ASSERT_FALSE(andFlags.any(TestFlags::ONE | TestFlags::TWO | TestFlags::THREE));
138 }
139
TEST(Flags,Equality)140 TEST(Flags, Equality) {
141 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
142 Flags<TestFlags> flags2 = TestFlags::ONE | TestFlags::TWO;
143 ASSERT_EQ(flags1, flags2);
144 }
145
TEST(Flags,Inequality)146 TEST(Flags, Inequality) {
147 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
148 Flags<TestFlags> flags2 = TestFlags::ONE | TestFlags::THREE;
149 ASSERT_NE(flags1, flags2);
150 }
151
TEST(Flags,EqualsOperator)152 TEST(Flags, EqualsOperator) {
153 Flags<TestFlags> flags;
154 flags = TestFlags::ONE;
155 ASSERT_TRUE(flags.test(TestFlags::ONE));
156 ASSERT_FALSE(flags.any(TestFlags::TWO | TestFlags::THREE));
157 }
158
TEST(Flags,EqualsOperator_DontShareState)159 TEST(Flags, EqualsOperator_DontShareState) {
160 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
161 Flags<TestFlags> flags2 = flags1;
162 ASSERT_EQ(flags1, flags2);
163
164 flags1 &= TestFlags::TWO;
165 ASSERT_NE(flags1, flags2);
166 }
167
TEST(Flags,GetValue)168 TEST(Flags, GetValue) {
169 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
170 ASSERT_EQ(flags.get(), 0x3);
171 }
172
TEST(Flags,String_NoFlags)173 TEST(Flags, String_NoFlags) {
174 Flags<TestFlags> flags;
175 ASSERT_EQ(flags.string(), "0x0");
176 }
177
TEST(Flags,String_KnownValues)178 TEST(Flags, String_KnownValues) {
179 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
180 ASSERT_EQ(flags.string(), "ONE | TWO");
181 }
182
TEST(Flags,String_UnknownValues)183 TEST(Flags, String_UnknownValues) {
184 auto flags = Flags<TestFlags>(0b1011);
185 ASSERT_EQ(flags.string(), "ONE | TWO | 0b1000");
186 }
187
TEST(FlagsIterator,IteratesOverAllFlags)188 TEST(FlagsIterator, IteratesOverAllFlags) {
189 Flags<TestFlags> flags1 = TestFlags::ONE | TestFlags::TWO;
190 Flags<TestFlags> flags2;
191 for (TestFlags f : flags1) {
192 flags2 |= f;
193 }
194 ASSERT_EQ(flags2, flags1);
195 }
196
TEST(FlagsIterator,IteratesInExpectedOrder)197 TEST(FlagsIterator, IteratesInExpectedOrder) {
198 const std::vector<TestFlags> flagOrder = {TestFlags::ONE, TestFlags::TWO};
199 Flags<TestFlags> flags;
200 for (TestFlags f : flagOrder) {
201 flags |= f;
202 }
203
204 size_t idx = 0;
205 auto iter = flags.begin();
206 while (iter != flags.end() && idx < flagOrder.size()) {
207 // Make sure the order is what we expect
208 ASSERT_EQ(*iter, flagOrder[idx]);
209 iter++;
210 idx++;
211 }
212 ASSERT_EQ(iter, flags.end());
213 }
TEST(FlagsIterator,PostFixIncrement)214 TEST(FlagsIterator, PostFixIncrement) {
215 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
216 auto iter = flags.begin();
217 ASSERT_EQ(*(iter++), TestFlags::ONE);
218 ASSERT_EQ(*iter, TestFlags::TWO);
219 ASSERT_EQ(*(iter++), TestFlags::TWO);
220 ASSERT_EQ(iter, flags.end());
221 }
222
TEST(FlagsIterator,PreFixIncrement)223 TEST(FlagsIterator, PreFixIncrement) {
224 Flags<TestFlags> flags = TestFlags::ONE | TestFlags::TWO;
225 auto iter = flags.begin();
226 ASSERT_EQ(*++iter, TestFlags::TWO);
227 ASSERT_EQ(++iter, flags.end());
228 }
229
230 } // namespace android::test
231