1 /*
2  * Copyright 2016 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "Flagged_test"
19 
20 #include <gtest/gtest.h>
21 
22 #include <media/stagefright/foundation/Flagged.h>
23 
24 namespace android {
25 
26 /**
27  * Helper template that can be used to print values in static_assert error messages.
28  *
29  * Use integers here.
30  */
31 template<bool, int ...N>
32 struct _print_as_warning { };
33 
34 template<int ...N>
35 struct _print_as_warning<true, N...> : std::true_type { };
36 
37 #define static_assert_equals(a, b, msg) \
38 static_assert(_print_as_warning<(a) == (b), a, b>::value, msg)
39 
40 class FlaggedTest : public ::testing::Test {
41 protected:
42     // empty structs
43     struct A0 { };
44     struct A1 { };
45     struct A_A0 : public A0 { };
46 
47     // simple struct
48     struct BB {
49         int32_t i;
50         uint32_t u;
51     };
52 
53     // struct inheriting from A0
54     struct BB_A0 : public A0 {
55         int32_t i;
56         uint32_t u;
57     };
58 
59     // struct inheriting from struct inheriting A0
60     struct BB_AA0 : public A_A0 {
61         int32_t i;
62         uint32_t u;
63     };
64 
65     // struct that wraps
66     struct WBBA0 {
67         BB_A0 b;
68     };
69 
70     struct WBBA0_A1 : public A1 {
71         BB_A0 b;
72     };
73 
74     struct WBBA0_A0 : public A0 {
75         BB_A0 b;
76     };
77 
78     struct WBB_A0 : public A0 {
79         BB b;
80     };
81 
82     struct WBBA0_AA0 : public A_A0 {
83         BB_A0 b;
84     };
85 
86     struct WBBAA0_A0 : public A0 {
87         BB_AA0 b;
88     };
89 
90     struct WWBBA0_A0 : public A0 {
91         WBBA0 b;
92     };
93 };
94 
95 /**
96  * This test is here to confirm the handling of wrapping classes that inherit from an interface
97  * while also inheriting from that same interface. While we no longer use this construct, we want
98  * to track if this defect is ever fixed.
99  */
TEST_F(FlaggedTest,StaticSanityTests)100 TEST_F(FlaggedTest, StaticSanityTests) {
101     static_assert(sizeof(A0) == 1, "");
102     static_assert(sizeof(A1) == 1, "");
103     static_assert(sizeof(A_A0) == 1, "");
104 
105     static constexpr size_t size = sizeof(BB); // original [pair]
106 
107     // inheriting from A0 does not increase size
108     static_assert(sizeof(BB_A0) == size, ""); // [pair]:A0
109     static_assert(sizeof(BB_AA0) == size, ""); // [pair]:[:A0]
110 
111      // wrapping a class that inherits from A0 does not increase size
112     static_assert(sizeof(WBBA0) == size, ""); // [ [pair]:[:A0] ]
113 
114     // wrapping a class that inherits from A0 while also inheriting from A1 does not increase size
115     static_assert(sizeof(WBBA0_A1) == size, ""); // [ [pair]:A0 ]:A1
116 
117     // wrapping a class that inherits from A0 while also inheriting from A0 DOES increase size
118     EXPECT_GT(sizeof(WBBA0_A0), size); // [ [pair]:A0 ]:A0
119 
120     // wrapping a class that does not inherit from A0 while inheriting from A0 does not increase
121     // size
122     static_assert(sizeof(WBB_A0) == size, ""); // [[pair]]:A0
123 
124     // wrapping a class that inherits from A0 while also inheriting from a class that inherits
125     // from A0 does increase size
126     EXPECT_GT(sizeof(WBBA0_AA0), size); // [ [pair]:A0 ]:[:A0]
127 
128     // wrapping a class that indirectly inherits from A0 while also inheriting from A0 does
129     // increase size
130     EXPECT_GT(sizeof(WBBAA0_A0), size); // [ [pair]:[:A0] ]:A0
131 
132     // wrapping a class that inherits from A0 while also inheriting A0 does increase size
133     EXPECT_GT(sizeof(WWBBA0_A0), size); //  [ [pair]:A0 ]:A0
134 }
135 
136 enum FLAG : int32_t {
137     kMask0 = 0x0FF,
138     kFlag0_A = 0x0AA,
139     kFlag0_B = 0x0BB,
140     kFlag0_C = 0x0CC,
141     kMask1 = 0xFF0,
142     kFlag1_A = 0xAA0,
143     kFlag1_B = 0xBB0,
144     kFlag1_C = 0xCC0,
145     kMaskCommon = 0x0F0,
146 };
147 
TEST_F(FlaggedTest,BasicExample)148 TEST_F(FlaggedTest, BasicExample) {
149     enum SafeFlags : uint32_t {
150       kUnsafe,
151       kSafe,
152       kSafeMask = _Flagged_helper::minMask(kSafe),
153     };
154     typedef Flagged<int32_t, SafeFlags, kSafeMask> safeInt32;
155 
156     safeInt32 a(kUnsafe);
157     a.setFlags(kSafe);
158     a.get() = 15;
159     EXPECT_EQ(a.flags(), kSafe);
160     EXPECT_EQ(a.get(), 15);
161 
162     enum OriginFlags : uint32_t {
163       kUnknown,
164       kConst,
165       kCalculated,
166       kComponent,
167       kApplication,
168       kFile,
169       kBinder,
170       kOriginMask = _Flagged_helper::minMask(kBinder),
171     };
172     typedef Flagged<safeInt32, OriginFlags, kOriginMask>
173              trackedSafeInt32;
174 
175     static_assert(sizeof(trackedSafeInt32) == sizeof(safeInt32), "");
176 
177     trackedSafeInt32 b(kConst, kSafe, 1);
178     EXPECT_EQ(b.flags(), kConst);
179     EXPECT_EQ(b.get().flags(), kSafe);
180     EXPECT_EQ(b.get().get(), 1);
181     b.setFlags(kCalculated);
182     volatile bool overflow = true;
183     b.get().setFlags(overflow ? kUnsafe : kSafe);
184 
185     enum ValidatedFlags : uint32_t {
186       kUnsafeV = kUnsafe,
187       kSafeV = kSafe,
188       kValidated = kSafe | 2,
189       kSharedMaskV = kSafeMask,
190       kValidatedMask = _Flagged_helper::minMask(kValidated),
191     };
192     typedef Flagged<safeInt32, ValidatedFlags, kValidatedMask, kSharedMaskV> validatedInt32;
193 
194     validatedInt32 v(kUnsafeV, kSafe, 10);
195     EXPECT_EQ(v.flags(), kUnsafeV);
196     EXPECT_EQ(v.get().flags(), kUnsafe);  // !kUnsafeV overrides kSafe
197     EXPECT_EQ(v.get().get(), 10);
198     v.setFlags(kValidated);
199     EXPECT_EQ(v.flags(), kValidated);
200     EXPECT_EQ(v.get().flags(), kSafe);
201     v.get().setFlags(kUnsafe);
202     EXPECT_EQ(v.flags(), 2);  // NOTE: sharing masks with enums allows strange situations to occur
203 }
204 
TEST_F(FlaggedTest,_Flagged_helper_Test)205 TEST_F(FlaggedTest, _Flagged_helper_Test) {
206     using helper = _Flagged_helper;
207 
208     using i32 = int32_t;
209     using u32 = uint32_t;
210     using u8 = uint8_t;
211 
212     // base2
213     static_assert(Flagged<i32, u32, 0u, 0u, 0>::sFlagMask == 0u, "");
214     static_assert(Flagged<i32, u32, 0u, 0u, 0>::sFlagShift == 0, "");
215     static_assert(Flagged<i32, u32, 0u, 0u, 0>::sEffectiveMask == 0u, "");
216 
217     static_assert(Flagged<i32, u32, 0u, 0u, 10>::sFlagMask == 0u, "");
218     static_assert(Flagged<i32, u32, 0u, 0u, 10>::sFlagShift == 10, "");
219     static_assert(Flagged<i32, u32, 0u, 0u, 10>::sEffectiveMask == 0u, "");
220 
221     static_assert(Flagged<i32, u32, 0u, 0u, -1>::sFlagMask == 0u, "");
222     static_assert(Flagged<i32, u32, 0u, 0u, -1>::sFlagShift == 0, "");
223     static_assert(Flagged<i32, u32, 0u, 0u, -1>::sEffectiveMask == 0u, "");
224 
225     static_assert(Flagged<i32, u32, 99u, 0u, 0>::sFlagMask == 99u, "");
226     static_assert(Flagged<i32, u32, 99u, 0u, 0>::sFlagShift == 0, "");
227     static_assert(Flagged<i32, u32, 99u, 0u, 0>::sEffectiveMask == 99u, "");
228 
229     static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sFlagMask == 0x99u, "");
230     static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sFlagShift == 12, "");
231     static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sEffectiveMask == 0x99000u, "");
232 
233     static_assert(Flagged<i32, u32, 99u, 0u, -1>::sFlagMask == 99u, "");
234     static_assert(Flagged<i32, u32, 99u, 0u, -1>::sFlagShift == 0, "");
235     static_assert(Flagged<i32, u32, 99u, 0u, -1>::sEffectiveMask == 99u, "");
236 
237     // mask_of<T, Flag>
238     // also Flagged<> no default
239     typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 0 /* shift */> i32_800f_0;
240     typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 4 /* shift */> i32_800f_4;
241     // this also tests that these types can be instantiated
242     static_assert(sizeof(i32_800f_0) >= sizeof(i32) + sizeof(u32),
243                   "should be at least size of component types");
244     static_assert(sizeof(i32_800f_4) == sizeof(i32_800f_0), "regardless of shift");
245     static_assert(!i32_800f_0::sFlagCombined, "");
246     static_assert(!i32_800f_4::sFlagCombined, "");
247 
248     static_assert(helper::mask_of<i32_800f_0, u32>::value == 0x800F, "incorrect mask");
249     static_assert(helper::mask_of<i32_800f_0, i32>::value == 0,
250                   "mask should be 0 when types mismatch");
251     static_assert(helper::mask_of<i32_800f_0, u32>::effective_value == 0x800F, "incorrect mask");
252     static_assert(helper::mask_of<i32_800f_0, i32>::effective_value == 0,
253                   "mask should be 0 when types mismatch");
254     static_assert(helper::mask_of<i32_800f_0, u32>::shift == 0, "incorrect shift");
255     static_assert(helper::mask_of<i32_800f_0, i32>::shift == 0,
256                   "shift should be 0 when types mismatch");
257 
258     static_assert(helper::mask_of<i32_800f_4, u32>::value == 0x800F, "incorrect mask");
259     static_assert(helper::mask_of<i32_800f_4, i32>::value == 0,
260                   "mask should be 0 when types mismatch");
261     static_assert(helper::mask_of<i32_800f_4, u32>::effective_value == 0x800F0, "incorrect mask");
262     static_assert(helper::mask_of<i32_800f_4, i32>::effective_value == 0,
263                   "mask should be 0 when types mismatch");
264     static_assert(helper::mask_of<i32_800f_4, u32>::shift == 4, "incorrect shift");
265     static_assert(helper::mask_of<i32_800f_4, i32>::shift == 0,
266                   "shift should be 0 when types mismatch");
267     static_assert(helper::mask_of<i32, u32>::value == 0, "mask should be 0 if not masked");
268     static_assert(helper::mask_of<i32, i32>::value == 0, "mask should be 0 if not masked");
269 
270     // lshift(value, n)
271     static_assert(helper::lshift(0U, 0) == 0U, "");
272     static_assert(helper::lshift(0U, 30) == 0U, "");
273     static_assert(helper::lshift(1U, 0) == 1U, "");
274     static_assert(helper::lshift(1U, 10) == 1024U, "");
275     static_assert(helper::lshift(10U, 10) == 10240U, "");
276     static_assert(helper::lshift(10, 10) == 10240, "");
277     static_assert(helper::lshift(-10, 0) == -10, "");
278     // static_assert(helper::lshift(-10, 10) == -10240, ""); // error: left shift of negative value
279 
280     // minMask(maxValue)
281     static_assert(helper::minMask(0U) == 0U, "lowest 0 bits");
282     static_assert(helper::minMask(1U) == 1U, "lowest 1 bit");
283     static_assert(helper::minMask(2U) == 3U, "lowest 2 bits");
284     static_assert(helper::minMask(3U) == 3U, "lowest 2 bits");
285     static_assert(helper::minMask(4U) == 7U, "lowest 3 bits");
286     static_assert(helper::minMask(~0U) == ~0U, "all bits");
287     // static_assert(helper::minMask(10) == 0xF, "all bits"); // error: must be unsigned
288 
289     // topBits(n)
290     static_assert(helper::topBits<u32>(0) == 0U, "top 0 bit");
291     static_assert(helper::topBits<u32>(1) == 0x80000000U, "top 1 bit");
292     static_assert(helper::topBits<u32>(2) == 0xC0000000U, "top 2 bits");
293     static_assert(helper::topBits<u32>(12) == 0xFFF00000U, "top 12 bits");
294     static_assert(helper::topBits<u32>(32) == 0xFFFFFFFFU, "all bits");
295     // static_assert(helper::topBits<u32>(33) == 0xFFFFFFFFU, ""); // should OVERFLOW
296 
297     static_assert(helper::topBits<u8>(0) == 0U, "top 0 bit");
298     static_assert(helper::topBits<u8>(1) == 0x80U, "top 1 bit");
299     static_assert(helper::topBits<u8>(2) == 0xC0U, "top 2 bit");
300     static_assert(helper::topBits<u8>(8) == 0xFFU, "all bits");
301     // static_assert(helper::topBits<u8>(9) == 0xFFU, ""); // should OVERFLOW
302 
303     // getShift(mask, base, shared, base-shift, base-effective)
304     static_assert(helper::getShift(0u, 0u, 0u, 0, 0u) == 0, "no flag require no shift");
305     static_assert(helper::getShift(0u, 0u, 1u, 0, 0u) == -1,
306                   "shared must be within mask and base mask");
307     static_assert(helper::getShift(0u, 1u, 1u, 0, 1u) == -1, "shared must be within mask");
308     static_assert(helper::getShift(0u, 1u, 0u, 0, 1u) == 0,
309                   "no flags require no shift even with base mask");
310     static_assert(helper::getShift(0u, 1u, 0u, 1, 2u) == 0,
311                   "no flags require no shift even with shifted base mask");
312     static_assert(helper::getShift(1u, 0u, 0u, 0, 0u) == 0, "no base mask requires no shift");
313     static_assert(helper::getShift(1u, 1u, 0u, 0, 1u) == 1,
314                   "overlapping mask and basemask requires shift");
315     static_assert(helper::getShift(1u, 1u, 0u, 0, 1u) == 1,
316                   "overlapping mask and basemask requires shift");
317     static_assert(helper::getShift(1u, 1u, 1u, 0, 1u) == 0,
318                   "shared mask requires using base shift");
319     static_assert(helper::getShift(1u, 1u, 1u, 1, 2u) == 1,
320                   "shared mask requires using base shift");
321     static_assert(helper::getShift(3u, 5u, 1u, 0, 5u) == 0,
322                   "mask and basemask that overlap only in shared region requires no shift");
323     static_assert(helper::getShift(3u, 7u, 1u, 0, 7u) == -1,
324                   "mask and basemask must not overlap in more than shared region");
325     static_assert(helper::getShift(1u, 0u, 1u, 0, 0u) == -1, "shared must be within base mask");
326 
327     static_assert(helper::getShift(0u, 1u, 0u, 1, 1u) == -2, "effective mask must cover base mask");
328     static_assert(helper::getShift(0u, 5u, 0u, 1, 2u) == -2, "effective mask must cover base mask");
329     static_assert(helper::getShift(0u, 5u, 0u, 1, 10u) == 0, "");
330     static_assert(helper::getShift(0u, 5u, 0u, 1, 31u) == 0,
331                   "effective mask can be larger than base mask");
332 
333     static_assert(helper::getShift(0x800Fu, 0x800Fu, 0x800Fu, 0, 0x800Fu) == 0,
334                   "(0x800F << 0) & 0x800F == 0x800F");
335     static_assert(helper::getShift(0x800Fu, 0x800Fu, 0x800Fu, 16, 0x800F0000u) == 16,
336                   "(0x800F << 0) & 0x800F == 0x800F");
337     static_assert(helper::getShift(0x1800Fu, 0x800Fu, 0x800Fu, 0, 0x800Fu) == 0,
338                   "(0x1800F << 0) & 0x800F == 0x800F");
339     static_assert(helper::getShift(0x1800Fu, 0x800Fu, 0x800Fu, 16, 0x800F0000u) == -1,
340                   "(0x1800F << 16) overflows");
341 
342     // verify that when not sharing masks, effective mask makes the difference
343     static_assert(helper::getShift(0x800Fu, 0u, 0u, 0, 0x800Fu) == 4,
344                   "(0x800F << 4) & 0x800F == 0");
345     static_assert(helper::getShift(0x800Fu, 0x2u, 0u, 0, 0x8002u) == 2,
346                   "(0x800F << 2) & 0x8002 == 0");
347     static_assert(helper::getShift(0x800Fu, 0x1u, 0u, 15, 0x8001u) == 1,
348                   "(0x800F << 1) & 0x8001 == 0");
349     static_assert(helper::getShift(0x800Fu, 0x800Fu, 0u, 16, 0x800F0000u) == 0,
350                   "0x800F & 0x800F0000 == 0");
351     static_assert(helper::getShift(0x800Fu, 0x800F8000u, 0u, 0, 0x800F8000u) == 5,
352                   "(0x800F << 5) & 0x800F8000 == 0");
353     static_assert(helper::getShift(0x800Fu, 0xF0000u, 0u, 0, 0x800F8000u) == 5,
354                   "(0x800F << 5) & 0x800F8000 == 0");
355     static_assert(helper::getShift(0x800Fu, 0x1Fu, 0u, 15, 0x800F8000u) == 5,
356                   "(0x800F << 5) & 0x800F8000 == 0");
357     static_assert(helper::getShift(0xFFu, 0x80808080u, 0u, 0, 0x80808080u) == -1,
358                   "0xFF always overlaps with 0x80808080");
359     static_assert(helper::getShift(0xFFu, 0x10001000u, 0u, 3, 0x80808080u) == -1,
360                   "0xFF always overlaps with 0x80808080");
361     static_assert(helper::getShift(0xFFu, 0x80808040u, 0u, 0, 0x80808040u) == 7,
362                   "(0xFF << 7) & 0x 80808040 == 0");
363 
364     // verify min_shift (mask must be positive or no shift can be required)
365     static_assert(helper::getShift(0xFF, 0x40808040, 0, 0, 0x40808040) == 7, "");
366     static_assert(helper::getShift((i32)0x800000FF, 0x40808040, 0, 0, 0x40808040) == -1, "");
367     static_assert(helper::getShift(0x100000FF, 0x40808040, 0, 0, 0x40808040) == -1, "");
368     static_assert(helper::getShift(0xFF, (i32)0x80808040, 0, 0, (i32)0x80808040) == 7, "");
369     static_assert(helper::getShift((i32)0x80007F80, 0x40808040, 0, 0, 0x40808040) == 0, "");
370 
371     // shared mask can also be negative (but not shift can be required)
372     static_assert(helper::getShift((i32)0x80007F80, (i32)0xC0808040, (i32)0x80000000,
373                                    0, (i32)0xC0808040) == 0, "");
374     static_assert(helper::getShift((i32)0x80007F80, (i32)0xC0808040, (i32)0xC0000000,
375                                    0, (i32)0xC0808040) == -1, "");
376     static_assert(helper::getShift((i32)0x80007F80, (i32)0x60404020, (i32)0x60000000,
377                                    1, (i32)0xC0808040) == -1, "");
378 
379     // min_shift
380     typedef Flagged<i32, u32, 0u> i32_0_0;
381     typedef Flagged<i32, u32, 1u> i32_1_0;
382     typedef Flagged<i32, u32, 1u, 0u, 1> i32_1_1;
383 
384     // this is a wrapper over getShift, so same test cases apply when T is flagged
385     static_assert(helper::min_shift<i32_0_0, u32, 0u, 0u>::value == 0, "");
386     static_assert(helper::min_shift<i32_0_0, u32, 0u, 1u>::value == -1, "");
387     static_assert(helper::min_shift<i32_1_0, u32, 0u, 1u>::value == -1, "");
388     static_assert(helper::min_shift<i32_1_0, u32, 0u, 0u>::value == 0, "");
389     static_assert(helper::min_shift<i32_0_0, u32, 1u, 0u>::value == 0, "");
390     static_assert(helper::min_shift<i32_1_0, u32, 1u, 0u>::value == 1, "");
391     static_assert(helper::min_shift<i32_1_0, u32, 1u, 1u>::value == 0, "");
392     static_assert(helper::min_shift<i32_1_1, u32, 1u, 1u>::value == 1, "");
393     static_assert(helper::min_shift<i32_1_1, u32, 3u, 0u>::value == 2, "");
394     static_assert(helper::min_shift<Flagged<i32, u32, 5u>, u32, 3u, 1u>::value == 0, "");
395     static_assert(helper::min_shift<Flagged<i32, u32, 7u>, u32, 3u, 1u>::value == -1, "");
396     static_assert(helper::min_shift<i32_0_0, u32, 1u, 1u>::value == -1, "");
397 
398     static_assert(helper::min_shift<i32_800f_0, u32, 0x800Fu, 0u>::value == 4, "");
399     static_assert(helper::min_shift<i32_800f_4, u32, 0x1800Fu, 0x800Fu>::value == 4, "");
400     static_assert(helper::min_shift<i32_800f_4, u32, 0x800Fu, 0u>::value == 0, "");
401     static_assert(helper::min_shift<Flagged<i32, u32, 0x8002u>, u32, 0x800Fu, 0u>::value == 2, "");
402     static_assert(helper::min_shift<Flagged<i32, u32, 0x8001u>, u32, 0x800Fu, 0u>::value == 1, "");
403     static_assert(
404             helper::min_shift<Flagged<i32, u32, 0x800Fu, 0u, 16>, u32, 0x800Fu, 0u>::value == 0, "");
405     static_assert(
406             helper::min_shift<Flagged<i32, u32, 0x800F8000u>, u32, 0x800Fu, 0u>::value == 5, "");
407     static_assert(
408             helper::min_shift<Flagged<i32, u32, 0x80808080u>, u32, 0xFFu, 0u>::value == -1, "");
409     static_assert(
410             helper::min_shift<Flagged<i32, u32, 0x80808040u>, u32, 0xFFu, 0u>::value == 7, "");
411 
412     // for min_shift, non-tagged type behaves as if having base mask of 0
413     static_assert(helper::min_shift<i32, u32, 0u, 0u>::value == 0, "");
414     static_assert(helper::min_shift<u32, u32, 0u, 0u>::value == 0, "");
415     static_assert(helper::min_shift<i32, u32, 0u, 0u>::value == 0, "");
416     static_assert(helper::min_shift<i32, u32, 0u, 1u>::value == -1, "");
417     static_assert(helper::min_shift<i32, u32, 1u, 0u>::value == 0, "");
418     static_assert(helper::min_shift<i32, u32, 1u, 1u>::value == -1, "");
419 
420     // verify min_shift (mask must be positive or no shift can be required)
421     static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>, i32, 0xFF, 0>::value == 7, "");
422     static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
423                                     i32, (i32)0x800000FF, 0>::value == -1, "");
424     static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
425                                     i32, 0x100000FF, 0>::value == -1, "");
426     static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x80808040>,
427                                     i32, 0xFF, 0>::value == 7, "");
428     static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
429                                     i32, (i32)0x80007F80, 0>::value == 0, "");
430 
431     static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x80808040>,
432                                     i32, (i32)0x80007F80, (i32)0x80000000>::value == 0, "");
433     static_assert(helper::min_shift<Flagged<i32, i32, (i32)0xC0808040>,
434                                     i32, (i32)0x80007F80, (i32)0xC0000000>::value == -1, "");
435     // note: cannot create a flagged type with signed flag and shift
436     // static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x60404020, 0, 1>,
437     //                                i32, (i32)0x40003FC0, (i32)0x40000000>::value == -1, "");
438 
439     typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 16 /* shift */> i32_800f_16;
440     static_assert_equals(sizeof(i32_800f_16), sizeof(i32_800f_0), "");
441     // shifted mask overflows!
442     // typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 17 /* shift */> i32_800f_17;
443     // static_assert(sizeof(i32_800f_17) == sizeof(i32_800f_0), "");
444     typedef Flagged<i32, i32, 0x800F /* mask */, 0 /* shared mask */, 15 /* shift */> i32_800f_15i;
445     static_assert_equals(sizeof(i32_800f_15i), sizeof(i32_800f_0), "");
446     // shifted mask overflows!
447     // typedef Flagged<i32, i32, 0x800F /* mask */, 0 /* shared mask */, 16 /* shift */> i32_800f_16i;
448     // static_assert(sizeof(i32_800f_16i) == sizeof(i32_800f_0), "");
449 
450     // canCombine(mask, base, shared, shift, base-shift, base-effective)
451     static_assert(helper::canCombine(0u, 0u, 0u, 0, 0, 0u), "using no mask is valid");
452     static_assert(helper::canCombine(0u, 0u, 0u, 0, 0, 0u), "");
453     static_assert(helper::canCombine(0u, 0u, 0u, 4, 0, 0u), "");
454     static_assert(!helper::canCombine(0u, 0u, 1u, 0, 0, 0u),
455                   "shared mask must be the overlap of masks");
456     static_assert(helper::canCombine(1u, 0u, 0u, 0, 0, 0u), "");
457     static_assert(helper::canCombine(1u, 0u, 0u, 4, 0, 0u), "");
458     static_assert(helper::canCombine(3u, 5u, 1u, 0, 0, 5u), "");
459     static_assert(!helper::canCombine(3u, 3u, 3u, 1, 0, 3u), "shift must match when sharing mask");
460     static_assert(helper::canCombine(3u, 3u, 3u, 1, 1, 6u), "");
461     static_assert(!helper::canCombine(3u, 3u, 3u, 1, 2, 12u), "shift must match when sharing mask");
462     static_assert(!helper::canCombine(3u, 7u, 1u, 0, 0, 7u), "");
463     static_assert(!helper::canCombine(1u, 0u, 1u, 0, 0, 0u), "");
464 
465     static_assert(!helper::canCombine(0u, 1u, 1u, 0, 0, 1u),
466                   "shared mask must be the overlap of masks");
467     static_assert(helper::canCombine(0u, 1u, 0u, 0, 0, 1u), "");
468     static_assert(helper::canCombine(0u, 1u, 0u, 4, 0, 1u), "");
469     static_assert(helper::canCombine(1u, 1u, 0u, 1, 0, 1u), "");
470     static_assert(!helper::canCombine(1u, 1u, 0u, 0, 0, 1u), "");
471     static_assert(helper::canCombine(1u, 1u, 0u, 1, 0, 1u), "");
472     static_assert(helper::canCombine(1u, 1u, 1u, 0, 0, 1u), "");
473     static_assert(!helper::canCombine(1u, 1u, 1u, 1, 0, 1u), "shift must match when sharing mask");
474 
475     static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0u, 4, 0, 0x800Fu), "");
476     static_assert(!helper::canCombine(0x800Fu, 0x800Fu, 0u, 1, 0, 0x800Fu), "");
477     static_assert(helper::canCombine(0x800Fu, 0x8002u, 0u, 2, 0, 0x8002u), "");
478     static_assert(helper::canCombine(0x800Fu, 0x8001u, 0u, 1, 0, 0x8001u), "");
479     static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0u, 0, 16, 0x800F0000u), "");
480     static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0x800Fu, 16, 16, 0x800F0000u), "");
481     static_assert(!helper::canCombine(0x1800Fu, 0x800Fu, 0u, 0, 16, 0x800F0000u), "");
482     static_assert(!helper::canCombine(0x1800Fu, 0x800Fu, 0x800Fu, 16, 16, 0x800F0000u), "");
483     static_assert(helper::canCombine(0x800Fu, 0x800F8000u, 0u, 8, 0, 0x800F8000u), "");
484     static_assert(!helper::canCombine(0xFFu, 0x80808080u, 0u, -1, 0, 0x80808080u), "");
485     static_assert(helper::canCombine(0xFFu, 0x80808040u, 0u, 7, 0, 0x80808040u), "");
486     static_assert(helper::canCombine(0xFFu, 0x8000u, 0u, 7, 0, 0x80808040u), "");
487     static_assert(helper::canCombine(0xFFu, 0x101u, 0u, 7, 15, 0x80808040u), "");
488 
489     // can combine signed-flagged types only if mask is positive or no shift is required
490     static_assert(!helper::canCombine(0xFF, 0x40808040, 0, 0, 0, 0x40808040), "");
491     static_assert(helper::canCombine(0xFF, 0x40808040, 0, 7, 0, 0x40808040), "");
492     static_assert(!helper::canCombine((i32)0x800000FF, 0x40808040, 0, 0, 0, 0x40808040), "");
493     static_assert(!helper::canCombine((i32)0x800000FF, 0x40808040, 0, 7, 0, 0x40808040), "");
494     static_assert(!helper::canCombine(0x100000FF, 0x40808040, 0, 0, 0, 0x40808040), "");
495     static_assert(!helper::canCombine(0x100000FF, 0x40808040, 0, 7, 0, 0x40808040), "");
496     static_assert(!helper::canCombine(0xFF, (i32)0x80808040, 0, 0, 0, (i32)0x80808040), "");
497     static_assert(helper::canCombine(0xFF, (i32)0x80808040, 0, 7, 0, (i32)0x80808040), "");
498     static_assert(helper::canCombine((i32)0x80007F80, 0x40808040, 0, 0, 0, 0x40808040), "");
499 
500     static_assert(helper::canCombine((i32)0x80007F80, (i32)0x80808040, (i32)0x80000000, 0, 0, (i32)0x80808040), "");
501     static_assert(!helper::canCombine((i32)0xC0007F80, (i32)0x80808040, (i32)0xC0000000, 0, 0, (i32)0x80808040), "");
502     static_assert(!helper::canCombine((i32)0x80007F80, (i32)0x80808040, (i32)0x80000000, 1, 0, (i32)0x80808040), "");
503     static_assert(!helper::canCombine((i32)0xC0007F80, (i32)0x80808040, (i32)0xC0000000, 1, 0, (i32)0x80808040), "");
504 
505     // can_combine<T, Flag, MASK, [SHARED_MASK], [SHIFT]
506     static_assert(helper::can_combine<i32_0_0, u32, 0u>::value, "");
507     static_assert(helper::can_combine<i32_0_0, u32, 0u, 0u>::value, "");
508     static_assert(helper::can_combine<i32_0_0, u32, 0u, 0u, 4>::value, "");
509     static_assert(!helper::can_combine<i32_0_0, u32, 0u, 1u>::value, "");
510     static_assert(helper::can_combine<i32_0_0, u32, 1u, 0u>::value, "");
511     static_assert(helper::can_combine<i32_0_0, u32, 1u, 0u, 4>::value, "");
512     static_assert(!helper::can_combine<i32_0_0, u32, 1u, 1u>::value, "");
513 
514     static_assert(!helper::can_combine<i32_1_0, u32, 0u, 1u>::value, "");
515     static_assert(helper::can_combine<i32_1_0, u32, 0u, 0u>::value, "");
516     static_assert(helper::can_combine<i32_1_0, u32, 0u, 0u, 4>::value, "");
517     static_assert(helper::can_combine<i32_1_0, u32, 1u, 0u>::value, "");
518     static_assert(!helper::can_combine<i32_1_0, u32, 1u, 0u, 0>::value, "");
519     static_assert(helper::can_combine<i32_1_0, u32, 1u, 0u, 1>::value, "");
520     static_assert(helper::can_combine<i32_1_0, u32, 1u, 1u>::value, "");
521     static_assert(helper::can_combine<i32_1_0, u32, 1u, 1u, 0>::value, "");
522     static_assert(!helper::can_combine<i32_1_0, u32, 1u, 1u, 1>::value,
523                   "shouldn't be able to use SHIFT with SHARED_MASK");
524 
525     static_assert(helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u, 4>::value, "");
526     static_assert(!helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u, 1>::value, "");
527     static_assert(helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u>::value, "");
528     static_assert(helper::can_combine<Flagged<i32, u32, 0x8002u>, u32, 0x800Fu, 0u>::value, "");
529     static_assert(helper::can_combine<Flagged<i32, u32, 0x8001u>, u32, 0x800Fu, 0u>::value, "");
530     static_assert(helper::can_combine<Flagged<i32, u32, 0x800F0000u>, u32, 0x800Fu, 0u>::value, "");
531     static_assert(helper::can_combine<Flagged<i32, u32, 0x800F8000u>, u32, 0x800Fu, 0u>::value, "");
532     static_assert(!helper::can_combine<Flagged<i32, u32, 0x80808080u>, u32, 0xFFu, 0u>::value, "");
533     static_assert(helper::can_combine<Flagged<i32, u32, 0x80808040u>, u32, 0xFFu, 0u>::value, "");
534 
535     // can combine signed-flagged types only if mask is positive or no shift is required
536     static_assert(helper::can_combine<Flagged<i32, i32, 0x40808040>, i32, 0xFF, 0>::value, "");
537     static_assert(!helper::can_combine<Flagged<i32, i32, 0x40808040>,
538                                        i32, (i32)0x800000FF, 0>::value, "");
539     static_assert(!helper::can_combine<Flagged<i32, i32, 0x40808040>,
540                                        i32, 0x100000FF, 0>::value, "");
541     static_assert(helper::can_combine<Flagged<i32, i32, (i32)0x80808040>, i32, 0xFF, 0>::value, "");
542     static_assert(helper::can_combine<Flagged<i32, i32, 0x40808040>,
543                                       i32, (i32)0x80007F80, 0>::value, "");
544 
545     static_assert(helper::can_combine<Flagged<i32, i32, (i32)0x80808040>,
546                                       i32, (i32)0x80007F80, (i32)0x80000000>::value, "");
547     static_assert(!helper::can_combine<Flagged<i32, i32, (i32)0xC0808040>,
548                                        i32, (i32)0x80007F80, (i32)0xC0000000>::value, "");
549 
550     static_assert(helper::min_shift<Flagged<i32, FLAG, (FLAG)0x80808040>,
551                                     FLAG, (FLAG)0x80007F80, (FLAG)0x80000000>::value == 0, "");
552     static_assert(helper::can_combine<Flagged<i32, FLAG, (FLAG)0x80808040>,
553                                       FLAG, (FLAG)0x80007F80, (FLAG)0x80000000>::value, "");
554 
555     // cannot combine non-tagged types
556     static_assert(!helper::can_combine<i32, u32, 0u, 0u>::value, "");
557     static_assert(!helper::can_combine<u32, u32, 0u, 0u>::value, "");
558     static_assert(!helper::can_combine<i32, u32, 0u, 0u>::value, "");
559     static_assert(!helper::can_combine<i32, u32, 0u, 1u>::value, "");
560     static_assert(!helper::can_combine<i32, u32, 1u, 0u>::value, "");
561     static_assert(!helper::can_combine<i32, u32, 1u, 1u>::value, "");
562 
563     typedef Flagged<i32_800f_0, u32, 0x800F /* mask */, 0 /* shared mask */> i32_800f_800f;
564     static_assert(i32_800f_800f::sFlagMask == 0x800F, "");
565     static_assert(i32_800f_800f::sFlagShift == 4, "");
566     static_assert(i32_800f_800f::sEffectiveMask == 0x880FF, "");
567     static_assert(!i32_800f_0::sFlagCombined, "");
568     static_assert(!i32_800f_4::sFlagCombined, "");
569 
570     static_assert(i32_800f_800f::sFlagCombined, "");
571     static_assert_equals(sizeof(i32_800f_800f), sizeof(i32_800f_0), "");
572 
573     typedef Flagged<i32_800f_0, u32, 0x1FFFF /* mask */> i32_800f_1ffff;
574     static_assert(i32_800f_1ffff::sFlagMask == 0x1FFFF, "");
575     static_assert(i32_800f_1ffff::sFlagShift == 0, "");
576     static_assert(i32_800f_1ffff::sEffectiveMask == 0x1FFFF, "");
577     static_assert(!i32_800f_1ffff::sFlagCombined, "");
578 
579     // operational tests
580     i32_800f_800f val(0x8000, 0x1234, 56);
581     EXPECT_EQ(val.get().get(), 56);
582     EXPECT_EQ(val.flags(), 0x8000u);
583     EXPECT_EQ(val.get().flags(), 0x1234u & 0x800F);
584     val.setFlags(0x12345);
585     EXPECT_EQ(val.flags(), 0x12345u & 0x800F);
586     EXPECT_EQ(val.get().flags(), 0x1234u & 0x800F);
587     val.get().setFlags(0x54321);
588     EXPECT_EQ(val.flags(), 0x12345u & 0x800F);
589     EXPECT_EQ(val.get().flags(), 0x54321u & 0x800F);
590     EXPECT_EQ(val.get().get(), 56);
591 
592     typedef Flagged<i32_800f_4, u32, 0x800F /* mask */, 0 /* shared mask */> i32_800f_800f_B;
593     static_assert(i32_800f_800f_B::sFlagMask == 0x800F, "");
594     static_assert(i32_800f_800f_B::sFlagShift == 0, "");
595     static_assert(i32_800f_800f_B::sEffectiveMask == 0x880FF, "");
596 
597     i32_800f_800f_B valB(0x8000, 0x1234, -987);
598     EXPECT_EQ(valB.get().get(), -987);
599     EXPECT_EQ(valB.flags(), 0x8000u);
600     EXPECT_EQ(valB.get().flags(), 0x1234u & 0x800F);
601     valB.setFlags(0x12345);
602     EXPECT_EQ(valB.flags(), 0x12345u & 0x800F);
603     EXPECT_EQ(valB.get().flags(), 0x1234u & 0x800F);
604     valB.get().setFlags(0x5C321);
605     EXPECT_EQ(valB.flags(), 0x12345u & 0x800F);
606     EXPECT_EQ(valB.get().flags(), 0x5C321u & 0x800F);
607     EXPECT_EQ(valB.get().get(), -987);
608 
609     typedef Flagged<Flagged<i32, u32, 0xFF>, u32, 0xFF0, 0xF0> i32_ff_ff0;
610     i32_ff_ff0 valC(0xABCD, 0x1234, 101);
611     EXPECT_EQ(valC.get().get(), 101);
612     EXPECT_EQ(valC.flags(), 0xBC0u);
613     EXPECT_EQ(valC.get().flags(), 0xC4u);
614     valC.setFlags(0x12345);
615     EXPECT_EQ(valC.flags(), 0x340u);
616     EXPECT_EQ(valC.get().flags(), 0x44u);
617     valC.get().setFlags(0x54321);
618     EXPECT_EQ(valC.flags(), 0x320u);
619     EXPECT_EQ(valC.get().flags(), 0x21u);
620     EXPECT_EQ(valC.get().get(), 101);
621 
622     // when combining flags (with no shift), it should work with signed flags
623     typedef Flagged<Flagged<i32, FLAG, kMask0>, FLAG, kMask1, kMaskCommon> i32_F_ff_ff0;
624     static_assert(i32_F_ff_ff0::sFlagCombined, "flags should be combined");
625 
626     i32_F_ff_ff0 valD(kFlag1_A, kFlag0_A, 1023);
627     EXPECT_EQ(valD.get().get(), 1023);
628     EXPECT_EQ(valD.flags(), kFlag1_A);
629     EXPECT_EQ(valD.get().flags(), kFlag0_A);
630     valD.setFlags(kFlag1_B);
631     EXPECT_EQ(valD.flags(), kFlag1_B);
632     EXPECT_EQ(valD.get().flags(), FLAG(0x0BA));
633     valD.get().setFlags(kFlag0_C);
634     EXPECT_EQ(valD.flags(), FLAG(0xBC0));
635     EXPECT_EQ(valD.get().flags(), kFlag0_C);
636     EXPECT_EQ(valD.get().get(), 1023);
637 }
638 
639 } // namespace android
640