/*
 * Copyright 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//#define LOG_NDEBUG 0
#define LOG_TAG "Flagged_test"

#include <gtest/gtest.h>

#include <media/stagefright/foundation/Flagged.h>

namespace android {

/**
 * Helper template that can be used to print values in static_assert error messages.
 *
 * Use integers here.
 */
template<bool, int ...N>
struct _print_as_warning { };

template<int ...N>
struct _print_as_warning<true, N...> : std::true_type { };

#define static_assert_equals(a, b, msg) \
static_assert(_print_as_warning<(a) == (b), a, b>::value, msg)

class FlaggedTest : public ::testing::Test {
protected:
    // empty structs
    struct A0 { };
    struct A1 { };
    struct A_A0 : public A0 { };

    // simple struct
    struct BB {
        int32_t i;
        uint32_t u;
    };

    // struct inheriting from A0
    struct BB_A0 : public A0 {
        int32_t i;
        uint32_t u;
    };

    // struct inheriting from struct inheriting A0
    struct BB_AA0 : public A_A0 {
        int32_t i;
        uint32_t u;
    };

    // struct that wraps
    struct WBBA0 {
        BB_A0 b;
    };

    struct WBBA0_A1 : public A1 {
        BB_A0 b;
    };

    struct WBBA0_A0 : public A0 {
        BB_A0 b;
    };

    struct WBB_A0 : public A0 {
        BB b;
    };

    struct WBBA0_AA0 : public A_A0 {
        BB_A0 b;
    };

    struct WBBAA0_A0 : public A0 {
        BB_AA0 b;
    };

    struct WWBBA0_A0 : public A0 {
        WBBA0 b;
    };
};

/**
 * This test is here to confirm the handling of wrapping classes that inherit from an interface
 * while also inheriting from that same interface. While we no longer use this construct, we want
 * to track if this defect is ever fixed.
 */
TEST_F(FlaggedTest, StaticSanityTests) {
    static_assert(sizeof(A0) == 1, "");
    static_assert(sizeof(A1) == 1, "");
    static_assert(sizeof(A_A0) == 1, "");

    static constexpr size_t size = sizeof(BB); // original [pair]

    // inheriting from A0 does not increase size
    static_assert(sizeof(BB_A0) == size, ""); // [pair]:A0
    static_assert(sizeof(BB_AA0) == size, ""); // [pair]:[:A0]

     // wrapping a class that inherits from A0 does not increase size
    static_assert(sizeof(WBBA0) == size, ""); // [ [pair]:[:A0] ]

    // wrapping a class that inherits from A0 while also inheriting from A1 does not increase size
    static_assert(sizeof(WBBA0_A1) == size, ""); // [ [pair]:A0 ]:A1

    // wrapping a class that inherits from A0 while also inheriting from A0 DOES increase size
    EXPECT_GT(sizeof(WBBA0_A0), size); // [ [pair]:A0 ]:A0

    // wrapping a class that does not inherit from A0 while inheriting from A0 does not increase
    // size
    static_assert(sizeof(WBB_A0) == size, ""); // [[pair]]:A0

    // wrapping a class that inherits from A0 while also inheriting from a class that inherits
    // from A0 does increase size
    EXPECT_GT(sizeof(WBBA0_AA0), size); // [ [pair]:A0 ]:[:A0]

    // wrapping a class that indirectly inherits from A0 while also inheriting from A0 does
    // increase size
    EXPECT_GT(sizeof(WBBAA0_A0), size); // [ [pair]:[:A0] ]:A0

    // wrapping a class that inherits from A0 while also inheriting A0 does increase size
    EXPECT_GT(sizeof(WWBBA0_A0), size); //  [ [pair]:A0 ]:A0
}

enum FLAG : int32_t {
    kMask0 = 0x0FF,
    kFlag0_A = 0x0AA,
    kFlag0_B = 0x0BB,
    kFlag0_C = 0x0CC,
    kMask1 = 0xFF0,
    kFlag1_A = 0xAA0,
    kFlag1_B = 0xBB0,
    kFlag1_C = 0xCC0,
    kMaskCommon = 0x0F0,
};

TEST_F(FlaggedTest, BasicExample) {
    enum SafeFlags : uint32_t {
      kUnsafe,
      kSafe,
      kSafeMask = _Flagged_helper::minMask(kSafe),
    };
    typedef Flagged<int32_t, SafeFlags, kSafeMask> safeInt32;

    safeInt32 a(kUnsafe);
    a.setFlags(kSafe);
    a.get() = 15;
    EXPECT_EQ(a.flags(), kSafe);
    EXPECT_EQ(a.get(), 15);

    enum OriginFlags : uint32_t {
      kUnknown,
      kConst,
      kCalculated,
      kComponent,
      kApplication,
      kFile,
      kBinder,
      kOriginMask = _Flagged_helper::minMask(kBinder),
    };
    typedef Flagged<safeInt32, OriginFlags, kOriginMask>
             trackedSafeInt32;

    static_assert(sizeof(trackedSafeInt32) == sizeof(safeInt32), "");

    trackedSafeInt32 b(kConst, kSafe, 1);
    EXPECT_EQ(b.flags(), kConst);
    EXPECT_EQ(b.get().flags(), kSafe);
    EXPECT_EQ(b.get().get(), 1);
    b.setFlags(kCalculated);
    volatile bool overflow = true;
    b.get().setFlags(overflow ? kUnsafe : kSafe);

    enum ValidatedFlags : uint32_t {
      kUnsafeV = kUnsafe,
      kSafeV = kSafe,
      kValidated = kSafe | 2,
      kSharedMaskV = kSafeMask,
      kValidatedMask = _Flagged_helper::minMask(kValidated),
    };
    typedef Flagged<safeInt32, ValidatedFlags, kValidatedMask, kSharedMaskV> validatedInt32;

    validatedInt32 v(kUnsafeV, kSafe, 10);
    EXPECT_EQ(v.flags(), kUnsafeV);
    EXPECT_EQ(v.get().flags(), kUnsafe);  // !kUnsafeV overrides kSafe
    EXPECT_EQ(v.get().get(), 10);
    v.setFlags(kValidated);
    EXPECT_EQ(v.flags(), kValidated);
    EXPECT_EQ(v.get().flags(), kSafe);
    v.get().setFlags(kUnsafe);
    EXPECT_EQ(v.flags(), 2);  // NOTE: sharing masks with enums allows strange situations to occur
}

TEST_F(FlaggedTest, _Flagged_helper_Test) {
    using helper = _Flagged_helper;

    using i32 = int32_t;
    using u32 = uint32_t;
    using u8 = uint8_t;

    // base2
    static_assert(Flagged<i32, u32, 0u, 0u, 0>::sFlagMask == 0u, "");
    static_assert(Flagged<i32, u32, 0u, 0u, 0>::sFlagShift == 0, "");
    static_assert(Flagged<i32, u32, 0u, 0u, 0>::sEffectiveMask == 0u, "");

    static_assert(Flagged<i32, u32, 0u, 0u, 10>::sFlagMask == 0u, "");
    static_assert(Flagged<i32, u32, 0u, 0u, 10>::sFlagShift == 10, "");
    static_assert(Flagged<i32, u32, 0u, 0u, 10>::sEffectiveMask == 0u, "");

    static_assert(Flagged<i32, u32, 0u, 0u, -1>::sFlagMask == 0u, "");
    static_assert(Flagged<i32, u32, 0u, 0u, -1>::sFlagShift == 0, "");
    static_assert(Flagged<i32, u32, 0u, 0u, -1>::sEffectiveMask == 0u, "");

    static_assert(Flagged<i32, u32, 99u, 0u, 0>::sFlagMask == 99u, "");
    static_assert(Flagged<i32, u32, 99u, 0u, 0>::sFlagShift == 0, "");
    static_assert(Flagged<i32, u32, 99u, 0u, 0>::sEffectiveMask == 99u, "");

    static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sFlagMask == 0x99u, "");
    static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sFlagShift == 12, "");
    static_assert(Flagged<i32, u32, 0x99u, 0u, 12>::sEffectiveMask == 0x99000u, "");

    static_assert(Flagged<i32, u32, 99u, 0u, -1>::sFlagMask == 99u, "");
    static_assert(Flagged<i32, u32, 99u, 0u, -1>::sFlagShift == 0, "");
    static_assert(Flagged<i32, u32, 99u, 0u, -1>::sEffectiveMask == 99u, "");

    // mask_of<T, Flag>
    // also Flagged<> no default
    typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 0 /* shift */> i32_800f_0;
    typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 4 /* shift */> i32_800f_4;
    // this also tests that these types can be instantiated
    static_assert(sizeof(i32_800f_0) >= sizeof(i32) + sizeof(u32),
                  "should be at least size of component types");
    static_assert(sizeof(i32_800f_4) == sizeof(i32_800f_0), "regardless of shift");
    static_assert(!i32_800f_0::sFlagCombined, "");
    static_assert(!i32_800f_4::sFlagCombined, "");

    static_assert(helper::mask_of<i32_800f_0, u32>::value == 0x800F, "incorrect mask");
    static_assert(helper::mask_of<i32_800f_0, i32>::value == 0,
                  "mask should be 0 when types mismatch");
    static_assert(helper::mask_of<i32_800f_0, u32>::effective_value == 0x800F, "incorrect mask");
    static_assert(helper::mask_of<i32_800f_0, i32>::effective_value == 0,
                  "mask should be 0 when types mismatch");
    static_assert(helper::mask_of<i32_800f_0, u32>::shift == 0, "incorrect shift");
    static_assert(helper::mask_of<i32_800f_0, i32>::shift == 0,
                  "shift should be 0 when types mismatch");

    static_assert(helper::mask_of<i32_800f_4, u32>::value == 0x800F, "incorrect mask");
    static_assert(helper::mask_of<i32_800f_4, i32>::value == 0,
                  "mask should be 0 when types mismatch");
    static_assert(helper::mask_of<i32_800f_4, u32>::effective_value == 0x800F0, "incorrect mask");
    static_assert(helper::mask_of<i32_800f_4, i32>::effective_value == 0,
                  "mask should be 0 when types mismatch");
    static_assert(helper::mask_of<i32_800f_4, u32>::shift == 4, "incorrect shift");
    static_assert(helper::mask_of<i32_800f_4, i32>::shift == 0,
                  "shift should be 0 when types mismatch");
    static_assert(helper::mask_of<i32, u32>::value == 0, "mask should be 0 if not masked");
    static_assert(helper::mask_of<i32, i32>::value == 0, "mask should be 0 if not masked");

    // lshift(value, n)
    static_assert(helper::lshift(0U, 0) == 0U, "");
    static_assert(helper::lshift(0U, 30) == 0U, "");
    static_assert(helper::lshift(1U, 0) == 1U, "");
    static_assert(helper::lshift(1U, 10) == 1024U, "");
    static_assert(helper::lshift(10U, 10) == 10240U, "");
    static_assert(helper::lshift(10, 10) == 10240, "");
    static_assert(helper::lshift(-10, 0) == -10, "");
    // static_assert(helper::lshift(-10, 10) == -10240, ""); // error: left shift of negative value

    // minMask(maxValue)
    static_assert(helper::minMask(0U) == 0U, "lowest 0 bits");
    static_assert(helper::minMask(1U) == 1U, "lowest 1 bit");
    static_assert(helper::minMask(2U) == 3U, "lowest 2 bits");
    static_assert(helper::minMask(3U) == 3U, "lowest 2 bits");
    static_assert(helper::minMask(4U) == 7U, "lowest 3 bits");
    static_assert(helper::minMask(~0U) == ~0U, "all bits");
    // static_assert(helper::minMask(10) == 0xF, "all bits"); // error: must be unsigned

    // topBits(n)
    static_assert(helper::topBits<u32>(0) == 0U, "top 0 bit");
    static_assert(helper::topBits<u32>(1) == 0x80000000U, "top 1 bit");
    static_assert(helper::topBits<u32>(2) == 0xC0000000U, "top 2 bits");
    static_assert(helper::topBits<u32>(12) == 0xFFF00000U, "top 12 bits");
    static_assert(helper::topBits<u32>(32) == 0xFFFFFFFFU, "all bits");
    // static_assert(helper::topBits<u32>(33) == 0xFFFFFFFFU, ""); // should OVERFLOW

    static_assert(helper::topBits<u8>(0) == 0U, "top 0 bit");
    static_assert(helper::topBits<u8>(1) == 0x80U, "top 1 bit");
    static_assert(helper::topBits<u8>(2) == 0xC0U, "top 2 bit");
    static_assert(helper::topBits<u8>(8) == 0xFFU, "all bits");
    // static_assert(helper::topBits<u8>(9) == 0xFFU, ""); // should OVERFLOW

    // getShift(mask, base, shared, base-shift, base-effective)
    static_assert(helper::getShift(0u, 0u, 0u, 0, 0u) == 0, "no flag require no shift");
    static_assert(helper::getShift(0u, 0u, 1u, 0, 0u) == -1,
                  "shared must be within mask and base mask");
    static_assert(helper::getShift(0u, 1u, 1u, 0, 1u) == -1, "shared must be within mask");
    static_assert(helper::getShift(0u, 1u, 0u, 0, 1u) == 0,
                  "no flags require no shift even with base mask");
    static_assert(helper::getShift(0u, 1u, 0u, 1, 2u) == 0,
                  "no flags require no shift even with shifted base mask");
    static_assert(helper::getShift(1u, 0u, 0u, 0, 0u) == 0, "no base mask requires no shift");
    static_assert(helper::getShift(1u, 1u, 0u, 0, 1u) == 1,
                  "overlapping mask and basemask requires shift");
    static_assert(helper::getShift(1u, 1u, 0u, 0, 1u) == 1,
                  "overlapping mask and basemask requires shift");
    static_assert(helper::getShift(1u, 1u, 1u, 0, 1u) == 0,
                  "shared mask requires using base shift");
    static_assert(helper::getShift(1u, 1u, 1u, 1, 2u) == 1,
                  "shared mask requires using base shift");
    static_assert(helper::getShift(3u, 5u, 1u, 0, 5u) == 0,
                  "mask and basemask that overlap only in shared region requires no shift");
    static_assert(helper::getShift(3u, 7u, 1u, 0, 7u) == -1,
                  "mask and basemask must not overlap in more than shared region");
    static_assert(helper::getShift(1u, 0u, 1u, 0, 0u) == -1, "shared must be within base mask");

    static_assert(helper::getShift(0u, 1u, 0u, 1, 1u) == -2, "effective mask must cover base mask");
    static_assert(helper::getShift(0u, 5u, 0u, 1, 2u) == -2, "effective mask must cover base mask");
    static_assert(helper::getShift(0u, 5u, 0u, 1, 10u) == 0, "");
    static_assert(helper::getShift(0u, 5u, 0u, 1, 31u) == 0,
                  "effective mask can be larger than base mask");

    static_assert(helper::getShift(0x800Fu, 0x800Fu, 0x800Fu, 0, 0x800Fu) == 0,
                  "(0x800F << 0) & 0x800F == 0x800F");
    static_assert(helper::getShift(0x800Fu, 0x800Fu, 0x800Fu, 16, 0x800F0000u) == 16,
                  "(0x800F << 0) & 0x800F == 0x800F");
    static_assert(helper::getShift(0x1800Fu, 0x800Fu, 0x800Fu, 0, 0x800Fu) == 0,
                  "(0x1800F << 0) & 0x800F == 0x800F");
    static_assert(helper::getShift(0x1800Fu, 0x800Fu, 0x800Fu, 16, 0x800F0000u) == -1,
                  "(0x1800F << 16) overflows");

    // verify that when not sharing masks, effective mask makes the difference
    static_assert(helper::getShift(0x800Fu, 0u, 0u, 0, 0x800Fu) == 4,
                  "(0x800F << 4) & 0x800F == 0");
    static_assert(helper::getShift(0x800Fu, 0x2u, 0u, 0, 0x8002u) == 2,
                  "(0x800F << 2) & 0x8002 == 0");
    static_assert(helper::getShift(0x800Fu, 0x1u, 0u, 15, 0x8001u) == 1,
                  "(0x800F << 1) & 0x8001 == 0");
    static_assert(helper::getShift(0x800Fu, 0x800Fu, 0u, 16, 0x800F0000u) == 0,
                  "0x800F & 0x800F0000 == 0");
    static_assert(helper::getShift(0x800Fu, 0x800F8000u, 0u, 0, 0x800F8000u) == 5,
                  "(0x800F << 5) & 0x800F8000 == 0");
    static_assert(helper::getShift(0x800Fu, 0xF0000u, 0u, 0, 0x800F8000u) == 5,
                  "(0x800F << 5) & 0x800F8000 == 0");
    static_assert(helper::getShift(0x800Fu, 0x1Fu, 0u, 15, 0x800F8000u) == 5,
                  "(0x800F << 5) & 0x800F8000 == 0");
    static_assert(helper::getShift(0xFFu, 0x80808080u, 0u, 0, 0x80808080u) == -1,
                  "0xFF always overlaps with 0x80808080");
    static_assert(helper::getShift(0xFFu, 0x10001000u, 0u, 3, 0x80808080u) == -1,
                  "0xFF always overlaps with 0x80808080");
    static_assert(helper::getShift(0xFFu, 0x80808040u, 0u, 0, 0x80808040u) == 7,
                  "(0xFF << 7) & 0x 80808040 == 0");

    // verify min_shift (mask must be positive or no shift can be required)
    static_assert(helper::getShift(0xFF, 0x40808040, 0, 0, 0x40808040) == 7, "");
    static_assert(helper::getShift((i32)0x800000FF, 0x40808040, 0, 0, 0x40808040) == -1, "");
    static_assert(helper::getShift(0x100000FF, 0x40808040, 0, 0, 0x40808040) == -1, "");
    static_assert(helper::getShift(0xFF, (i32)0x80808040, 0, 0, (i32)0x80808040) == 7, "");
    static_assert(helper::getShift((i32)0x80007F80, 0x40808040, 0, 0, 0x40808040) == 0, "");

    // shared mask can also be negative (but not shift can be required)
    static_assert(helper::getShift((i32)0x80007F80, (i32)0xC0808040, (i32)0x80000000,
                                   0, (i32)0xC0808040) == 0, "");
    static_assert(helper::getShift((i32)0x80007F80, (i32)0xC0808040, (i32)0xC0000000,
                                   0, (i32)0xC0808040) == -1, "");
    static_assert(helper::getShift((i32)0x80007F80, (i32)0x60404020, (i32)0x60000000,
                                   1, (i32)0xC0808040) == -1, "");

    // min_shift
    typedef Flagged<i32, u32, 0u> i32_0_0;
    typedef Flagged<i32, u32, 1u> i32_1_0;
    typedef Flagged<i32, u32, 1u, 0u, 1> i32_1_1;

    // this is a wrapper over getShift, so same test cases apply when T is flagged
    static_assert(helper::min_shift<i32_0_0, u32, 0u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32_0_0, u32, 0u, 1u>::value == -1, "");
    static_assert(helper::min_shift<i32_1_0, u32, 0u, 1u>::value == -1, "");
    static_assert(helper::min_shift<i32_1_0, u32, 0u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32_0_0, u32, 1u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32_1_0, u32, 1u, 0u>::value == 1, "");
    static_assert(helper::min_shift<i32_1_0, u32, 1u, 1u>::value == 0, "");
    static_assert(helper::min_shift<i32_1_1, u32, 1u, 1u>::value == 1, "");
    static_assert(helper::min_shift<i32_1_1, u32, 3u, 0u>::value == 2, "");
    static_assert(helper::min_shift<Flagged<i32, u32, 5u>, u32, 3u, 1u>::value == 0, "");
    static_assert(helper::min_shift<Flagged<i32, u32, 7u>, u32, 3u, 1u>::value == -1, "");
    static_assert(helper::min_shift<i32_0_0, u32, 1u, 1u>::value == -1, "");

    static_assert(helper::min_shift<i32_800f_0, u32, 0x800Fu, 0u>::value == 4, "");
    static_assert(helper::min_shift<i32_800f_4, u32, 0x1800Fu, 0x800Fu>::value == 4, "");
    static_assert(helper::min_shift<i32_800f_4, u32, 0x800Fu, 0u>::value == 0, "");
    static_assert(helper::min_shift<Flagged<i32, u32, 0x8002u>, u32, 0x800Fu, 0u>::value == 2, "");
    static_assert(helper::min_shift<Flagged<i32, u32, 0x8001u>, u32, 0x800Fu, 0u>::value == 1, "");
    static_assert(
            helper::min_shift<Flagged<i32, u32, 0x800Fu, 0u, 16>, u32, 0x800Fu, 0u>::value == 0, "");
    static_assert(
            helper::min_shift<Flagged<i32, u32, 0x800F8000u>, u32, 0x800Fu, 0u>::value == 5, "");
    static_assert(
            helper::min_shift<Flagged<i32, u32, 0x80808080u>, u32, 0xFFu, 0u>::value == -1, "");
    static_assert(
            helper::min_shift<Flagged<i32, u32, 0x80808040u>, u32, 0xFFu, 0u>::value == 7, "");

    // for min_shift, non-tagged type behaves as if having base mask of 0
    static_assert(helper::min_shift<i32, u32, 0u, 0u>::value == 0, "");
    static_assert(helper::min_shift<u32, u32, 0u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32, u32, 0u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32, u32, 0u, 1u>::value == -1, "");
    static_assert(helper::min_shift<i32, u32, 1u, 0u>::value == 0, "");
    static_assert(helper::min_shift<i32, u32, 1u, 1u>::value == -1, "");

    // verify min_shift (mask must be positive or no shift can be required)
    static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>, i32, 0xFF, 0>::value == 7, "");
    static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
                                    i32, (i32)0x800000FF, 0>::value == -1, "");
    static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
                                    i32, 0x100000FF, 0>::value == -1, "");
    static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x80808040>,
                                    i32, 0xFF, 0>::value == 7, "");
    static_assert(helper::min_shift<Flagged<i32, i32, 0x40808040>,
                                    i32, (i32)0x80007F80, 0>::value == 0, "");

    static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x80808040>,
                                    i32, (i32)0x80007F80, (i32)0x80000000>::value == 0, "");
    static_assert(helper::min_shift<Flagged<i32, i32, (i32)0xC0808040>,
                                    i32, (i32)0x80007F80, (i32)0xC0000000>::value == -1, "");
    // note: cannot create a flagged type with signed flag and shift
    // static_assert(helper::min_shift<Flagged<i32, i32, (i32)0x60404020, 0, 1>,
    //                                i32, (i32)0x40003FC0, (i32)0x40000000>::value == -1, "");

    typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 16 /* shift */> i32_800f_16;
    static_assert_equals(sizeof(i32_800f_16), sizeof(i32_800f_0), "");
    // shifted mask overflows!
    // typedef Flagged<i32, u32, 0x800F /* mask */, 0 /* shared mask */, 17 /* shift */> i32_800f_17;
    // static_assert(sizeof(i32_800f_17) == sizeof(i32_800f_0), "");
    typedef Flagged<i32, i32, 0x800F /* mask */, 0 /* shared mask */, 15 /* shift */> i32_800f_15i;
    static_assert_equals(sizeof(i32_800f_15i), sizeof(i32_800f_0), "");
    // shifted mask overflows!
    // typedef Flagged<i32, i32, 0x800F /* mask */, 0 /* shared mask */, 16 /* shift */> i32_800f_16i;
    // static_assert(sizeof(i32_800f_16i) == sizeof(i32_800f_0), "");

    // canCombine(mask, base, shared, shift, base-shift, base-effective)
    static_assert(helper::canCombine(0u, 0u, 0u, 0, 0, 0u), "using no mask is valid");
    static_assert(helper::canCombine(0u, 0u, 0u, 0, 0, 0u), "");
    static_assert(helper::canCombine(0u, 0u, 0u, 4, 0, 0u), "");
    static_assert(!helper::canCombine(0u, 0u, 1u, 0, 0, 0u),
                  "shared mask must be the overlap of masks");
    static_assert(helper::canCombine(1u, 0u, 0u, 0, 0, 0u), "");
    static_assert(helper::canCombine(1u, 0u, 0u, 4, 0, 0u), "");
    static_assert(helper::canCombine(3u, 5u, 1u, 0, 0, 5u), "");
    static_assert(!helper::canCombine(3u, 3u, 3u, 1, 0, 3u), "shift must match when sharing mask");
    static_assert(helper::canCombine(3u, 3u, 3u, 1, 1, 6u), "");
    static_assert(!helper::canCombine(3u, 3u, 3u, 1, 2, 12u), "shift must match when sharing mask");
    static_assert(!helper::canCombine(3u, 7u, 1u, 0, 0, 7u), "");
    static_assert(!helper::canCombine(1u, 0u, 1u, 0, 0, 0u), "");

    static_assert(!helper::canCombine(0u, 1u, 1u, 0, 0, 1u),
                  "shared mask must be the overlap of masks");
    static_assert(helper::canCombine(0u, 1u, 0u, 0, 0, 1u), "");
    static_assert(helper::canCombine(0u, 1u, 0u, 4, 0, 1u), "");
    static_assert(helper::canCombine(1u, 1u, 0u, 1, 0, 1u), "");
    static_assert(!helper::canCombine(1u, 1u, 0u, 0, 0, 1u), "");
    static_assert(helper::canCombine(1u, 1u, 0u, 1, 0, 1u), "");
    static_assert(helper::canCombine(1u, 1u, 1u, 0, 0, 1u), "");
    static_assert(!helper::canCombine(1u, 1u, 1u, 1, 0, 1u), "shift must match when sharing mask");

    static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0u, 4, 0, 0x800Fu), "");
    static_assert(!helper::canCombine(0x800Fu, 0x800Fu, 0u, 1, 0, 0x800Fu), "");
    static_assert(helper::canCombine(0x800Fu, 0x8002u, 0u, 2, 0, 0x8002u), "");
    static_assert(helper::canCombine(0x800Fu, 0x8001u, 0u, 1, 0, 0x8001u), "");
    static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0u, 0, 16, 0x800F0000u), "");
    static_assert(helper::canCombine(0x800Fu, 0x800Fu, 0x800Fu, 16, 16, 0x800F0000u), "");
    static_assert(!helper::canCombine(0x1800Fu, 0x800Fu, 0u, 0, 16, 0x800F0000u), "");
    static_assert(!helper::canCombine(0x1800Fu, 0x800Fu, 0x800Fu, 16, 16, 0x800F0000u), "");
    static_assert(helper::canCombine(0x800Fu, 0x800F8000u, 0u, 8, 0, 0x800F8000u), "");
    static_assert(!helper::canCombine(0xFFu, 0x80808080u, 0u, -1, 0, 0x80808080u), "");
    static_assert(helper::canCombine(0xFFu, 0x80808040u, 0u, 7, 0, 0x80808040u), "");
    static_assert(helper::canCombine(0xFFu, 0x8000u, 0u, 7, 0, 0x80808040u), "");
    static_assert(helper::canCombine(0xFFu, 0x101u, 0u, 7, 15, 0x80808040u), "");

    // can combine signed-flagged types only if mask is positive or no shift is required
    static_assert(!helper::canCombine(0xFF, 0x40808040, 0, 0, 0, 0x40808040), "");
    static_assert(helper::canCombine(0xFF, 0x40808040, 0, 7, 0, 0x40808040), "");
    static_assert(!helper::canCombine((i32)0x800000FF, 0x40808040, 0, 0, 0, 0x40808040), "");
    static_assert(!helper::canCombine((i32)0x800000FF, 0x40808040, 0, 7, 0, 0x40808040), "");
    static_assert(!helper::canCombine(0x100000FF, 0x40808040, 0, 0, 0, 0x40808040), "");
    static_assert(!helper::canCombine(0x100000FF, 0x40808040, 0, 7, 0, 0x40808040), "");
    static_assert(!helper::canCombine(0xFF, (i32)0x80808040, 0, 0, 0, (i32)0x80808040), "");
    static_assert(helper::canCombine(0xFF, (i32)0x80808040, 0, 7, 0, (i32)0x80808040), "");
    static_assert(helper::canCombine((i32)0x80007F80, 0x40808040, 0, 0, 0, 0x40808040), "");

    static_assert(helper::canCombine((i32)0x80007F80, (i32)0x80808040, (i32)0x80000000, 0, 0, (i32)0x80808040), "");
    static_assert(!helper::canCombine((i32)0xC0007F80, (i32)0x80808040, (i32)0xC0000000, 0, 0, (i32)0x80808040), "");
    static_assert(!helper::canCombine((i32)0x80007F80, (i32)0x80808040, (i32)0x80000000, 1, 0, (i32)0x80808040), "");
    static_assert(!helper::canCombine((i32)0xC0007F80, (i32)0x80808040, (i32)0xC0000000, 1, 0, (i32)0x80808040), "");

    // can_combine<T, Flag, MASK, [SHARED_MASK], [SHIFT]
    static_assert(helper::can_combine<i32_0_0, u32, 0u>::value, "");
    static_assert(helper::can_combine<i32_0_0, u32, 0u, 0u>::value, "");
    static_assert(helper::can_combine<i32_0_0, u32, 0u, 0u, 4>::value, "");
    static_assert(!helper::can_combine<i32_0_0, u32, 0u, 1u>::value, "");
    static_assert(helper::can_combine<i32_0_0, u32, 1u, 0u>::value, "");
    static_assert(helper::can_combine<i32_0_0, u32, 1u, 0u, 4>::value, "");
    static_assert(!helper::can_combine<i32_0_0, u32, 1u, 1u>::value, "");

    static_assert(!helper::can_combine<i32_1_0, u32, 0u, 1u>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 0u, 0u>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 0u, 0u, 4>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 1u, 0u>::value, "");
    static_assert(!helper::can_combine<i32_1_0, u32, 1u, 0u, 0>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 1u, 0u, 1>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 1u, 1u>::value, "");
    static_assert(helper::can_combine<i32_1_0, u32, 1u, 1u, 0>::value, "");
    static_assert(!helper::can_combine<i32_1_0, u32, 1u, 1u, 1>::value,
                  "shouldn't be able to use SHIFT with SHARED_MASK");

    static_assert(helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u, 4>::value, "");
    static_assert(!helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u, 1>::value, "");
    static_assert(helper::can_combine<i32_800f_0, u32, 0x800Fu, 0u>::value, "");
    static_assert(helper::can_combine<Flagged<i32, u32, 0x8002u>, u32, 0x800Fu, 0u>::value, "");
    static_assert(helper::can_combine<Flagged<i32, u32, 0x8001u>, u32, 0x800Fu, 0u>::value, "");
    static_assert(helper::can_combine<Flagged<i32, u32, 0x800F0000u>, u32, 0x800Fu, 0u>::value, "");
    static_assert(helper::can_combine<Flagged<i32, u32, 0x800F8000u>, u32, 0x800Fu, 0u>::value, "");
    static_assert(!helper::can_combine<Flagged<i32, u32, 0x80808080u>, u32, 0xFFu, 0u>::value, "");
    static_assert(helper::can_combine<Flagged<i32, u32, 0x80808040u>, u32, 0xFFu, 0u>::value, "");

    // can combine signed-flagged types only if mask is positive or no shift is required
    static_assert(helper::can_combine<Flagged<i32, i32, 0x40808040>, i32, 0xFF, 0>::value, "");
    static_assert(!helper::can_combine<Flagged<i32, i32, 0x40808040>,
                                       i32, (i32)0x800000FF, 0>::value, "");
    static_assert(!helper::can_combine<Flagged<i32, i32, 0x40808040>,
                                       i32, 0x100000FF, 0>::value, "");
    static_assert(helper::can_combine<Flagged<i32, i32, (i32)0x80808040>, i32, 0xFF, 0>::value, "");
    static_assert(helper::can_combine<Flagged<i32, i32, 0x40808040>,
                                      i32, (i32)0x80007F80, 0>::value, "");

    static_assert(helper::can_combine<Flagged<i32, i32, (i32)0x80808040>,
                                      i32, (i32)0x80007F80, (i32)0x80000000>::value, "");
    static_assert(!helper::can_combine<Flagged<i32, i32, (i32)0xC0808040>,
                                       i32, (i32)0x80007F80, (i32)0xC0000000>::value, "");

    static_assert(helper::min_shift<Flagged<i32, FLAG, (FLAG)0x80808040>,
                                    FLAG, (FLAG)0x80007F80, (FLAG)0x80000000>::value == 0, "");
    static_assert(helper::can_combine<Flagged<i32, FLAG, (FLAG)0x80808040>,
                                      FLAG, (FLAG)0x80007F80, (FLAG)0x80000000>::value, "");

    // cannot combine non-tagged types
    static_assert(!helper::can_combine<i32, u32, 0u, 0u>::value, "");
    static_assert(!helper::can_combine<u32, u32, 0u, 0u>::value, "");
    static_assert(!helper::can_combine<i32, u32, 0u, 0u>::value, "");
    static_assert(!helper::can_combine<i32, u32, 0u, 1u>::value, "");
    static_assert(!helper::can_combine<i32, u32, 1u, 0u>::value, "");
    static_assert(!helper::can_combine<i32, u32, 1u, 1u>::value, "");

    typedef Flagged<i32_800f_0, u32, 0x800F /* mask */, 0 /* shared mask */> i32_800f_800f;
    static_assert(i32_800f_800f::sFlagMask == 0x800F, "");
    static_assert(i32_800f_800f::sFlagShift == 4, "");
    static_assert(i32_800f_800f::sEffectiveMask == 0x880FF, "");
    static_assert(!i32_800f_0::sFlagCombined, "");
    static_assert(!i32_800f_4::sFlagCombined, "");

    static_assert(i32_800f_800f::sFlagCombined, "");
    static_assert_equals(sizeof(i32_800f_800f), sizeof(i32_800f_0), "");

    typedef Flagged<i32_800f_0, u32, 0x1FFFF /* mask */> i32_800f_1ffff;
    static_assert(i32_800f_1ffff::sFlagMask == 0x1FFFF, "");
    static_assert(i32_800f_1ffff::sFlagShift == 0, "");
    static_assert(i32_800f_1ffff::sEffectiveMask == 0x1FFFF, "");
    static_assert(!i32_800f_1ffff::sFlagCombined, "");

    // operational tests
    i32_800f_800f val(0x8000, 0x1234, 56);
    EXPECT_EQ(val.get().get(), 56);
    EXPECT_EQ(val.flags(), 0x8000u);
    EXPECT_EQ(val.get().flags(), 0x1234u & 0x800F);
    val.setFlags(0x12345);
    EXPECT_EQ(val.flags(), 0x12345u & 0x800F);
    EXPECT_EQ(val.get().flags(), 0x1234u & 0x800F);
    val.get().setFlags(0x54321);
    EXPECT_EQ(val.flags(), 0x12345u & 0x800F);
    EXPECT_EQ(val.get().flags(), 0x54321u & 0x800F);
    EXPECT_EQ(val.get().get(), 56);

    typedef Flagged<i32_800f_4, u32, 0x800F /* mask */, 0 /* shared mask */> i32_800f_800f_B;
    static_assert(i32_800f_800f_B::sFlagMask == 0x800F, "");
    static_assert(i32_800f_800f_B::sFlagShift == 0, "");
    static_assert(i32_800f_800f_B::sEffectiveMask == 0x880FF, "");

    i32_800f_800f_B valB(0x8000, 0x1234, -987);
    EXPECT_EQ(valB.get().get(), -987);
    EXPECT_EQ(valB.flags(), 0x8000u);
    EXPECT_EQ(valB.get().flags(), 0x1234u & 0x800F);
    valB.setFlags(0x12345);
    EXPECT_EQ(valB.flags(), 0x12345u & 0x800F);
    EXPECT_EQ(valB.get().flags(), 0x1234u & 0x800F);
    valB.get().setFlags(0x5C321);
    EXPECT_EQ(valB.flags(), 0x12345u & 0x800F);
    EXPECT_EQ(valB.get().flags(), 0x5C321u & 0x800F);
    EXPECT_EQ(valB.get().get(), -987);

    typedef Flagged<Flagged<i32, u32, 0xFF>, u32, 0xFF0, 0xF0> i32_ff_ff0;
    i32_ff_ff0 valC(0xABCD, 0x1234, 101);
    EXPECT_EQ(valC.get().get(), 101);
    EXPECT_EQ(valC.flags(), 0xBC0u);
    EXPECT_EQ(valC.get().flags(), 0xC4u);
    valC.setFlags(0x12345);
    EXPECT_EQ(valC.flags(), 0x340u);
    EXPECT_EQ(valC.get().flags(), 0x44u);
    valC.get().setFlags(0x54321);
    EXPECT_EQ(valC.flags(), 0x320u);
    EXPECT_EQ(valC.get().flags(), 0x21u);
    EXPECT_EQ(valC.get().get(), 101);

    // when combining flags (with no shift), it should work with signed flags
    typedef Flagged<Flagged<i32, FLAG, kMask0>, FLAG, kMask1, kMaskCommon> i32_F_ff_ff0;
    static_assert(i32_F_ff_ff0::sFlagCombined, "flags should be combined");

    i32_F_ff_ff0 valD(kFlag1_A, kFlag0_A, 1023);
    EXPECT_EQ(valD.get().get(), 1023);
    EXPECT_EQ(valD.flags(), kFlag1_A);
    EXPECT_EQ(valD.get().flags(), kFlag0_A);
    valD.setFlags(kFlag1_B);
    EXPECT_EQ(valD.flags(), kFlag1_B);
    EXPECT_EQ(valD.get().flags(), FLAG(0x0BA));
    valD.get().setFlags(kFlag0_C);
    EXPECT_EQ(valD.flags(), FLAG(0xBC0));
    EXPECT_EQ(valD.get().flags(), kFlag0_C);
    EXPECT_EQ(valD.get().get(), 1023);
}

} // namespace android