diff options
Diffstat (limited to 'runtime/base/bit_utils_test.cc')
| -rw-r--r-- | runtime/base/bit_utils_test.cc | 400 |
1 files changed, 400 insertions, 0 deletions
diff --git a/runtime/base/bit_utils_test.cc b/runtime/base/bit_utils_test.cc new file mode 100644 index 0000000..77bd0b8 --- /dev/null +++ b/runtime/base/bit_utils_test.cc @@ -0,0 +1,400 @@ +/* + * Copyright (C) 2015 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. + */ + +#include <vector> + +#include "bit_utils.h" + +#include "gtest/gtest.h" + +namespace art { + +// NOTE: CLZ(0u) is undefined. +static_assert(31 == CLZ<uint32_t>(1u), "TestCLZ32#1"); +static_assert(30 == CLZ<uint32_t>(2u), "TestCLZ32#2"); +static_assert(16 == CLZ<uint32_t>(0x00008765u), "TestCLZ32#3"); +static_assert(15 == CLZ<uint32_t>(0x00012345u), "TestCLZ32#4"); +static_assert(1 == CLZ<uint32_t>(0x43214321u), "TestCLZ32#5"); +static_assert(0 == CLZ<uint32_t>(0x87654321u), "TestCLZ32#6"); + +// NOTE: CLZ(0ull) is undefined. +static_assert(63 == CLZ<uint64_t>(UINT64_C(1)), "TestCLZ64#1"); +static_assert(62 == CLZ<uint64_t>(UINT64_C(3)), "TestCLZ64#2"); +static_assert(48 == CLZ<uint64_t>(UINT64_C(0x00008765)), "TestCLZ64#3"); +static_assert(32 == CLZ<uint64_t>(UINT64_C(0x87654321)), "TestCLZ64#4"); +static_assert(31 == CLZ<uint64_t>(UINT64_C(0x123456789)), "TestCLZ64#5"); +static_assert(16 == CLZ<uint64_t>(UINT64_C(0x876543211234)), "TestCLZ64#6"); +static_assert(1 == CLZ<uint64_t>(UINT64_C(0x4321432187654321)), "TestCLZ64#7"); +static_assert(0 == CLZ<uint64_t>(UINT64_C(0x8765432187654321)), "TestCLZ64#8"); + +// NOTE: CTZ(0u) is undefined. +static_assert(0 == CTZ<uint32_t>(1u), "TestCTZ32#1"); +static_assert(1 == CTZ<uint32_t>(2u), "TestCTZ32#2"); +static_assert(15 == CTZ<uint32_t>(0x45678000u), "TestCTZ32#3"); +static_assert(16 == CTZ<uint32_t>(0x43210000u), "TestCTZ32#4"); +static_assert(30 == CTZ<uint32_t>(0xc0000000u), "TestCTZ32#5"); +static_assert(31 == CTZ<uint32_t>(0x80000000u), "TestCTZ32#6"); + +// NOTE: CTZ(0ull) is undefined. +static_assert(0 == CTZ<uint64_t>(UINT64_C(1)), "TestCTZ64#1"); +static_assert(1 == CTZ<uint64_t>(UINT64_C(2)), "TestCTZ64#2"); +static_assert(16 == CTZ<uint64_t>(UINT64_C(0x43210000)), "TestCTZ64#3"); +static_assert(31 == CTZ<uint64_t>(UINT64_C(0x80000000)), "TestCTZ64#4"); +static_assert(32 == CTZ<uint64_t>(UINT64_C(0x8765432100000000)), "TestCTZ64#5"); +static_assert(48 == CTZ<uint64_t>(UINT64_C(0x4321000000000000)), "TestCTZ64#6"); +static_assert(62 == CTZ<uint64_t>(UINT64_C(0x4000000000000000)), "TestCTZ64#7"); +static_assert(63 == CTZ<uint64_t>(UINT64_C(0x8000000000000000)), "TestCTZ64#8"); + +static_assert(0 == POPCOUNT<uint32_t>(0u), "TestPOPCOUNT32#1"); +static_assert(1 == POPCOUNT<uint32_t>(8u), "TestPOPCOUNT32#2"); +static_assert(15 == POPCOUNT<uint32_t>(0x55555554u), "TestPOPCOUNT32#3"); +static_assert(16 == POPCOUNT<uint32_t>(0xaaaaaaaau), "TestPOPCOUNT32#4"); +static_assert(31 == POPCOUNT<uint32_t>(0xfffffffeu), "TestPOPCOUNT32#5"); +static_assert(32 == POPCOUNT<uint32_t>(0xffffffffu), "TestPOPCOUNT32#6"); + +static_assert(0 == POPCOUNT<uint64_t>(UINT64_C(0)), "TestPOPCOUNT64#1"); +static_assert(1 == POPCOUNT<uint64_t>(UINT64_C(0x40000)), "TestPOPCOUNT64#2"); +static_assert(16 == POPCOUNT<uint64_t>(UINT64_C(0x1414141482828282)), "TestPOPCOUNT64#3"); +static_assert(31 == POPCOUNT<uint64_t>(UINT64_C(0x0000ffff00007fff)), "TestPOPCOUNT64#4"); +static_assert(32 == POPCOUNT<uint64_t>(UINT64_C(0x5555555555555555)), "TestPOPCOUNT64#5"); +static_assert(48 == POPCOUNT<uint64_t>(UINT64_C(0x7777bbbbddddeeee)), "TestPOPCOUNT64#6"); +static_assert(63 == POPCOUNT<uint64_t>(UINT64_C(0x7fffffffffffffff)), "TestPOPCOUNT64#7"); +static_assert(64 == POPCOUNT<uint64_t>(UINT64_C(0xffffffffffffffff)), "TestPOPCOUNT64#8"); + +static_assert(-1 == MostSignificantBit<uint32_t>(0u), "TestMSB32#1"); +static_assert(0 == MostSignificantBit<uint32_t>(1u), "TestMSB32#2"); +static_assert(31 == MostSignificantBit<uint32_t>(~static_cast<uint32_t>(0u)), "TestMSB32#3"); +static_assert(2 == MostSignificantBit<uint32_t>(0b110), "TestMSB32#4"); +static_assert(2 == MostSignificantBit<uint32_t>(0b100), "TestMSB32#5"); + +static_assert(-1 == MostSignificantBit<uint64_t>(UINT64_C(0)), "TestMSB64#1"); +static_assert(0 == MostSignificantBit<uint64_t>(UINT64_C(1)), "TestMSB64#2"); +static_assert(63 == MostSignificantBit<uint64_t>(~UINT64_C(0)), "TestMSB64#3"); +static_assert(34 == MostSignificantBit<uint64_t>(UINT64_C(0x700000000)), "TestMSB64#4"); +static_assert(34 == MostSignificantBit<uint64_t>(UINT64_C(0x777777777)), "TestMSB64#5"); + +static_assert(-1 == LeastSignificantBit<uint32_t>(0u), "TestLSB32#1"); +static_assert(0 == LeastSignificantBit<uint32_t>(1u), "TestLSB32#1"); +static_assert(0 == LeastSignificantBit<uint32_t>(~static_cast<uint32_t>(0u)), "TestLSB32#1"); +static_assert(1 == LeastSignificantBit<uint32_t>(0b110), "TestLSB32#1"); +static_assert(2 == LeastSignificantBit<uint32_t>(0b100), "TestLSB32#1"); + +static_assert(-1 == LeastSignificantBit<uint64_t>(UINT64_C(0)), "TestLSB64#1"); +static_assert(0 == LeastSignificantBit<uint64_t>(UINT64_C(1)), "TestLSB64#2"); +static_assert(0 == LeastSignificantBit<uint64_t>(~UINT64_C(0)), "TestLSB64#3"); +static_assert(12 == LeastSignificantBit<uint64_t>(UINT64_C(0x5000)), "TestLSB64#4"); +static_assert(48 == LeastSignificantBit<uint64_t>(UINT64_C(0x5555000000000000)), "TestLSB64#5"); + +static_assert(0u == MinimumBitsToStore<uint32_t>(0u), "TestMinBits2Store32#1"); +static_assert(1u == MinimumBitsToStore<uint32_t>(1u), "TestMinBits2Store32#2"); +static_assert(2u == MinimumBitsToStore<uint32_t>(0b10u), "TestMinBits2Store32#3"); +static_assert(2u == MinimumBitsToStore<uint32_t>(0b11u), "TestMinBits2Store32#4"); +static_assert(3u == MinimumBitsToStore<uint32_t>(0b100u), "TestMinBits2Store32#5"); +static_assert(3u == MinimumBitsToStore<uint32_t>(0b110u), "TestMinBits2Store32#6"); +static_assert(3u == MinimumBitsToStore<uint32_t>(0b101u), "TestMinBits2Store32#7"); +static_assert(8u == MinimumBitsToStore<uint32_t>(0xFFu), "TestMinBits2Store32#8"); +static_assert(32u == MinimumBitsToStore<uint32_t>(~static_cast<uint32_t>(0u)), + "TestMinBits2Store32#9"); + +static_assert(0u == MinimumBitsToStore<uint64_t>(UINT64_C(0)), "TestMinBits2Store64#1"); +static_assert(1u == MinimumBitsToStore<uint64_t>(UINT64_C(1)), "TestMinBits2Store64#2"); +static_assert(2u == MinimumBitsToStore<uint64_t>(UINT64_C(0b10)), "TestMinBits2Store64#3"); +static_assert(2u == MinimumBitsToStore<uint64_t>(UINT64_C(0b11)), "TestMinBits2Store64#4"); +static_assert(3u == MinimumBitsToStore<uint64_t>(UINT64_C(0b100)), "TestMinBits2Store64#5"); +static_assert(3u == MinimumBitsToStore<uint64_t>(UINT64_C(0b110)), "TestMinBits2Store64#6"); +static_assert(3u == MinimumBitsToStore<uint64_t>(UINT64_C(0b101)), "TestMinBits2Store64#7"); +static_assert(8u == MinimumBitsToStore<uint64_t>(UINT64_C(0xFF)), "TestMinBits2Store64#8"); +static_assert(32u == MinimumBitsToStore<uint64_t>(UINT64_C(0xFFFFFFFF)), "TestMinBits2Store64#9"); +static_assert(33u == MinimumBitsToStore<uint64_t>(UINT64_C(0x1FFFFFFFF)), "TestMinBits2Store64#10"); +static_assert(64u == MinimumBitsToStore<uint64_t>(~UINT64_C(0)), "TestMinBits2Store64#11"); + +static_assert(0 == RoundUpToPowerOfTwo<uint32_t>(0u), "TestRoundUpPowerOfTwo32#1"); +static_assert(1 == RoundUpToPowerOfTwo<uint32_t>(1u), "TestRoundUpPowerOfTwo32#2"); +static_assert(2 == RoundUpToPowerOfTwo<uint32_t>(2u), "TestRoundUpPowerOfTwo32#3"); +static_assert(4 == RoundUpToPowerOfTwo<uint32_t>(3u), "TestRoundUpPowerOfTwo32#4"); +static_assert(8 == RoundUpToPowerOfTwo<uint32_t>(7u), "TestRoundUpPowerOfTwo32#5"); +static_assert(0x40000u == RoundUpToPowerOfTwo<uint32_t>(0x2aaaau), + "TestRoundUpPowerOfTwo32#6"); +static_assert(0x80000000u == RoundUpToPowerOfTwo<uint32_t>(0x40000001u), + "TestRoundUpPowerOfTwo32#7"); +static_assert(0x80000000u == RoundUpToPowerOfTwo<uint32_t>(0x80000000u), + "TestRoundUpPowerOfTwo32#8"); + +static_assert(0 == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(0)), "TestRoundUpPowerOfTwo64#1"); +static_assert(1 == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(1)), "TestRoundUpPowerOfTwo64#2"); +static_assert(2 == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(2)), "TestRoundUpPowerOfTwo64#3"); +static_assert(4 == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(3)), "TestRoundUpPowerOfTwo64#4"); +static_assert(8 == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(7)), "TestRoundUpPowerOfTwo64#5"); +static_assert(UINT64_C(0x40000) == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(0x2aaaa)), + "TestRoundUpPowerOfTwo64#6"); +static_assert( + UINT64_C(0x8000000000000000) == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(0x4000000000000001)), + "TestRoundUpPowerOfTwo64#7"); +static_assert( + UINT64_C(0x8000000000000000) == RoundUpToPowerOfTwo<uint64_t>(UINT64_C(0x8000000000000000)), + "TestRoundUpPowerOfTwo64#8"); + +static constexpr int64_t kInt32MinMinus1 = + static_cast<int64_t>(std::numeric_limits<int32_t>::min()) - 1; +static constexpr int64_t kInt32MaxPlus1 = + static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1; +static constexpr int64_t kUint32MaxPlus1 = + static_cast<int64_t>(std::numeric_limits<uint32_t>::max()) + 1; + +TEST(BitUtilsTest, TestIsInt32) { + EXPECT_FALSE(IsInt<int32_t>(1, -2)); + EXPECT_TRUE(IsInt<int32_t>(1, -1)); + EXPECT_TRUE(IsInt<int32_t>(1, 0)); + EXPECT_FALSE(IsInt<int32_t>(1, 1)); + EXPECT_FALSE(IsInt<int32_t>(4, -9)); + EXPECT_TRUE(IsInt<int32_t>(4, -8)); + EXPECT_TRUE(IsInt<int32_t>(4, 7)); + EXPECT_FALSE(IsInt<int32_t>(4, 8)); + EXPECT_FALSE(IsInt<int32_t>(31, std::numeric_limits<int32_t>::min())); + EXPECT_FALSE(IsInt<int32_t>(31, std::numeric_limits<int32_t>::max())); + EXPECT_TRUE(IsInt<int32_t>(32, std::numeric_limits<int32_t>::min())); + EXPECT_TRUE(IsInt<int32_t>(32, std::numeric_limits<int32_t>::max())); +} + +TEST(BitUtilsTest, TestIsInt64) { + EXPECT_FALSE(IsInt<int64_t>(1, -2)); + EXPECT_TRUE(IsInt<int64_t>(1, -1)); + EXPECT_TRUE(IsInt<int64_t>(1, 0)); + EXPECT_FALSE(IsInt<int64_t>(1, 1)); + EXPECT_FALSE(IsInt<int64_t>(4, -9)); + EXPECT_TRUE(IsInt<int64_t>(4, -8)); + EXPECT_TRUE(IsInt<int64_t>(4, 7)); + EXPECT_FALSE(IsInt<int64_t>(4, 8)); + EXPECT_FALSE(IsInt<int64_t>(31, std::numeric_limits<int32_t>::min())); + EXPECT_FALSE(IsInt<int64_t>(31, std::numeric_limits<int32_t>::max())); + EXPECT_TRUE(IsInt<int64_t>(32, std::numeric_limits<int32_t>::min())); + EXPECT_TRUE(IsInt<int64_t>(32, std::numeric_limits<int32_t>::max())); + EXPECT_FALSE(IsInt<int64_t>(32, kInt32MinMinus1)); + EXPECT_FALSE(IsInt<int64_t>(32, kInt32MaxPlus1)); + EXPECT_FALSE(IsInt<int64_t>(63, std::numeric_limits<int64_t>::min())); + EXPECT_FALSE(IsInt<int64_t>(63, std::numeric_limits<int64_t>::max())); + EXPECT_TRUE(IsInt<int64_t>(64, std::numeric_limits<int64_t>::min())); + EXPECT_TRUE(IsInt<int64_t>(64, std::numeric_limits<int64_t>::max())); +} + +static_assert(!IsInt<1, int32_t>(-2), "TestIsInt32#1"); +static_assert(IsInt<1, int32_t>(-1), "TestIsInt32#2"); +static_assert(IsInt<1, int32_t>(0), "TestIsInt32#3"); +static_assert(!IsInt<1, int32_t>(1), "TestIsInt32#4"); +static_assert(!IsInt<4, int32_t>(-9), "TestIsInt32#5"); +static_assert(IsInt<4, int32_t>(-8), "TestIsInt32#6"); +static_assert(IsInt<4, int32_t>(7), "TestIsInt32#7"); +static_assert(!IsInt<4, int32_t>(8), "TestIsInt32#8"); +static_assert(!IsInt<31, int32_t>(std::numeric_limits<int32_t>::min()), "TestIsInt32#9"); +static_assert(!IsInt<31, int32_t>(std::numeric_limits<int32_t>::max()), "TestIsInt32#10"); +static_assert(IsInt<32, int32_t>(std::numeric_limits<int32_t>::min()), "TestIsInt32#11"); +static_assert(IsInt<32, int32_t>(std::numeric_limits<int32_t>::max()), "TestIsInt32#12"); + +static_assert(!IsInt<1, int64_t>(-2), "TestIsInt64#1"); +static_assert(IsInt<1, int64_t>(-1), "TestIsInt64#2"); +static_assert(IsInt<1, int64_t>(0), "TestIsInt64#3"); +static_assert(!IsInt<1, int64_t>(1), "TestIsInt64#4"); +static_assert(!IsInt<4, int64_t>(-9), "TestIsInt64#5"); +static_assert(IsInt<4, int64_t>(-8), "TestIsInt64#6"); +static_assert(IsInt<4, int64_t>(7), "TestIsInt64#7"); +static_assert(!IsInt<4, int64_t>(8), "TestIsInt64#8"); +static_assert(!IsInt<31, int64_t>(std::numeric_limits<int32_t>::min()), "TestIsInt64#9"); +static_assert(!IsInt<31, int64_t>(std::numeric_limits<int32_t>::max()), "TestIsInt64#10"); +static_assert(IsInt<32, int64_t>(std::numeric_limits<int32_t>::min()), "TestIsInt64#11"); +static_assert(IsInt<32, int64_t>(std::numeric_limits<int32_t>::max()), "TestIsInt64#12"); +static_assert(!IsInt<32, int64_t>(kInt32MinMinus1), "TestIsInt64#13"); +static_assert(!IsInt<32, int64_t>(kInt32MaxPlus1), "TestIsInt64#14"); +static_assert(!IsInt<63, int64_t>(std::numeric_limits<int64_t>::min()), "TestIsInt64#15"); +static_assert(!IsInt<63, int64_t>(std::numeric_limits<int64_t>::max()), "TestIsInt64#16"); +static_assert(IsInt<64, int64_t>(std::numeric_limits<int64_t>::min()), "TestIsInt64#17"); +static_assert(IsInt<64, int64_t>(std::numeric_limits<int64_t>::max()), "TestIsInt64#18"); + +static_assert(!IsUint<1, int32_t>(-1), "TestIsUint32#1"); +static_assert(IsUint<1, int32_t>(0), "TestIsUint32#2"); +static_assert(IsUint<1, int32_t>(1), "TestIsUint32#3"); +static_assert(!IsUint<1, int32_t>(2), "TestIsUint32#4"); +static_assert(!IsUint<4, int32_t>(-1), "TestIsUint32#5"); +static_assert(IsUint<4, int32_t>(0), "TestIsUint32#6"); +static_assert(IsUint<4, int32_t>(15), "TestIsUint32#7"); +static_assert(!IsUint<4, int32_t>(16), "TestIsUint32#8"); +static_assert(!IsUint<30, int32_t>(std::numeric_limits<int32_t>::max()), "TestIsUint32#9"); +static_assert(IsUint<31, int32_t>(std::numeric_limits<int32_t>::max()), "TestIsUint32#10"); +static_assert(!IsUint<32, int32_t>(-1), "TestIsUint32#11"); +static_assert(IsUint<32, int32_t>(0), "TestIsUint32#11"); +static_assert(IsUint<32, uint32_t>(static_cast<uint32_t>(-1)), "TestIsUint32#12"); + +static_assert(!IsUint<1, int64_t>(-1), "TestIsUint64#1"); +static_assert(IsUint<1, int64_t>(0), "TestIsUint64#2"); +static_assert(IsUint<1, int64_t>(1), "TestIsUint64#3"); +static_assert(!IsUint<1, int64_t>(2), "TestIsUint64#4"); +static_assert(!IsUint<4, int64_t>(-1), "TestIsUint64#5"); +static_assert(IsUint<4, int64_t>(0), "TestIsUint64#6"); +static_assert(IsUint<4, int64_t>(15), "TestIsUint64#7"); +static_assert(!IsUint<4, int64_t>(16), "TestIsUint64#8"); +static_assert(!IsUint<30, int64_t>(std::numeric_limits<int32_t>::max()), "TestIsUint64#9"); +static_assert(IsUint<31, int64_t>(std::numeric_limits<int32_t>::max()), "TestIsUint64#10"); +static_assert(!IsUint<62, int64_t>(std::numeric_limits<int64_t>::max()), "TestIsUint64#11"); +static_assert(IsUint<63, int64_t>(std::numeric_limits<int64_t>::max()), "TestIsUint64#12"); +static_assert(!IsUint<64, int64_t>(-1), "TestIsUint64#13"); +static_assert(IsUint<64, int64_t>(0), "TestIsUint64#14"); +static_assert(IsUint<64, uint64_t>(static_cast<uint32_t>(-1)), "TestIsUint64#15"); + +static_assert(!IsAbsoluteUint<1, int32_t>(-2), "TestIsAbsoluteUint32#1"); +static_assert(IsAbsoluteUint<1, int32_t>(-1), "TestIsAbsoluteUint32#2"); +static_assert(IsAbsoluteUint<1, int32_t>(0), "TestIsAbsoluteUint32#3"); +static_assert(IsAbsoluteUint<1, int32_t>(1), "TestIsAbsoluteUint32#4"); +static_assert(!IsAbsoluteUint<1, int32_t>(2), "TestIsAbsoluteUint32#5"); +static_assert(!IsAbsoluteUint<4, int32_t>(-16), "TestIsAbsoluteUint32#6"); +static_assert(IsAbsoluteUint<4, int32_t>(-15), "TestIsAbsoluteUint32#7"); +static_assert(IsAbsoluteUint<4, int32_t>(0), "TestIsAbsoluteUint32#8"); +static_assert(IsAbsoluteUint<4, int32_t>(15), "TestIsAbsoluteUint32#9"); +static_assert(!IsAbsoluteUint<4, int32_t>(16), "TestIsAbsoluteUint32#10"); +static_assert(!IsAbsoluteUint<30, int32_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint32#11"); +static_assert(IsAbsoluteUint<31, int32_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint32#12"); +static_assert(!IsAbsoluteUint<31, int32_t>(std::numeric_limits<int32_t>::min()), + "TestIsAbsoluteUint32#13"); +static_assert(IsAbsoluteUint<31, int32_t>(std::numeric_limits<int32_t>::min() + 1), + "TestIsAbsoluteUint32#14"); +static_assert(IsAbsoluteUint<32, int32_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint32#15"); +static_assert(IsAbsoluteUint<32, int32_t>(std::numeric_limits<int32_t>::min()), + "TestIsAbsoluteUint32#16"); +static_assert(IsAbsoluteUint<32, int32_t>(0), "TestIsAbsoluteUint32#17"); + +static_assert(!IsAbsoluteUint<1, int64_t>(-2), "TestIsAbsoluteUint64#1"); +static_assert(IsAbsoluteUint<1, int64_t>(-1), "TestIsAbsoluteUint64#2"); +static_assert(IsAbsoluteUint<1, int64_t>(0), "TestIsAbsoluteUint64#3"); +static_assert(IsAbsoluteUint<1, int64_t>(1), "TestIsAbsoluteUint64#4"); +static_assert(!IsAbsoluteUint<1, int64_t>(2), "TestIsAbsoluteUint64#5"); +static_assert(!IsAbsoluteUint<4, int64_t>(-16), "TestIsAbsoluteUint64#6"); +static_assert(IsAbsoluteUint<4, int64_t>(-15), "TestIsAbsoluteUint64#7"); +static_assert(IsAbsoluteUint<4, int64_t>(0), "TestIsAbsoluteUint64#8"); +static_assert(IsAbsoluteUint<4, int64_t>(15), "TestIsAbsoluteUint64#9"); +static_assert(!IsAbsoluteUint<4, int64_t>(16), "TestIsAbsoluteUint64#10"); +static_assert(!IsAbsoluteUint<30, int64_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint64#11"); +static_assert(IsAbsoluteUint<31, int64_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint64#12"); +static_assert(!IsAbsoluteUint<31, int64_t>(std::numeric_limits<int32_t>::min()), + "TestIsAbsoluteUint64#13"); +static_assert(IsAbsoluteUint<31, int64_t>(std::numeric_limits<int32_t>::min() + 1), + "TestIsAbsoluteUint64#14"); +static_assert(IsAbsoluteUint<32, int64_t>(std::numeric_limits<int32_t>::max()), + "TestIsAbsoluteUint64#15"); +static_assert(IsAbsoluteUint<32, int64_t>(std::numeric_limits<int32_t>::min()), + "TestIsAbsoluteUint64#16"); +static_assert(!IsAbsoluteUint<62, int64_t>(std::numeric_limits<int64_t>::max()), + "TestIsAbsoluteUint64#17"); +static_assert(IsAbsoluteUint<63, int64_t>(std::numeric_limits<int64_t>::max()), + "TestIsAbsoluteUint64#18"); +static_assert(!IsAbsoluteUint<63, int64_t>(std::numeric_limits<int64_t>::min()), + "TestIsAbsoluteUint64#19"); +static_assert(IsAbsoluteUint<63, int64_t>(std::numeric_limits<int64_t>::min() + 1), + "TestIsAbsoluteUint64#20"); +static_assert(IsAbsoluteUint<64, int64_t>(std::numeric_limits<int64_t>::max()), + "TestIsAbsoluteUint64#21"); +static_assert(IsAbsoluteUint<64, int64_t>(std::numeric_limits<int64_t>::min()), + "TestIsAbsoluteUint64#22"); +static_assert(!IsAbsoluteUint<32, int64_t>(-kUint32MaxPlus1), "TestIsAbsoluteUint64#23"); +static_assert(IsAbsoluteUint<32, int64_t>(-kUint32MaxPlus1 + 1), "TestIsAbsoluteUint64#24"); +static_assert(IsAbsoluteUint<32, int64_t>(0), "TestIsAbsoluteUint64#25"); +static_assert(IsAbsoluteUint<64, int64_t>(0), "TestIsAbsoluteUint64#26"); +static_assert(IsAbsoluteUint<32, int64_t>(std::numeric_limits<uint32_t>::max()), + "TestIsAbsoluteUint64#27"); +static_assert(!IsAbsoluteUint<32, int64_t>(kUint32MaxPlus1), "TestIsAbsoluteUint64#28"); + +template <typename Container> +void CheckElements(const std::initializer_list<uint32_t>& expected, const Container& elements) { + auto expected_it = expected.begin(); + auto element_it = elements.begin(); + size_t idx = 0u; + while (expected_it != expected.end() && element_it != elements.end()) { + EXPECT_EQ(*expected_it, *element_it) << idx; + ++idx; + ++expected_it; + ++element_it; + } + ASSERT_TRUE(expected_it == expected.end() && element_it == elements.end()) + << std::boolalpha << (expected_it == expected.end()) << " " << (element_it == elements.end()); +} + +TEST(BitUtilsTest, TestLowToHighBits32) { + CheckElements({}, LowToHighBits<uint32_t>(0u)); + CheckElements({0}, LowToHighBits<uint32_t>(1u)); + CheckElements({15}, LowToHighBits<uint32_t>(0x8000u)); + CheckElements({31}, LowToHighBits<uint32_t>(0x80000000u)); + CheckElements({0, 31}, LowToHighBits<uint32_t>(0x80000001u)); + CheckElements({0, 1, 2, 3, 4, 5, 6, 7, 31}, LowToHighBits<uint32_t>(0x800000ffu)); + CheckElements({0, 8, 16, 24, 31}, LowToHighBits<uint32_t>(0x81010101u)); + CheckElements({16, 17, 30, 31}, LowToHighBits<uint32_t>(0xc0030000u)); + CheckElements({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + LowToHighBits<uint32_t>(0xffffffffu)); +} + +TEST(BitUtilsTest, TestLowToHighBits64) { + CheckElements({}, LowToHighBits<uint64_t>(UINT64_C(0))); + CheckElements({0}, LowToHighBits<uint64_t>(UINT64_C(1))); + CheckElements({32}, LowToHighBits<uint64_t>(UINT64_C(0x100000000))); + CheckElements({63}, LowToHighBits<uint64_t>(UINT64_C(0x8000000000000000))); + CheckElements({0, 63}, LowToHighBits<uint64_t>(UINT64_C(0x8000000000000001))); + CheckElements({0, 1, 2, 3, 4, 5, 6, 7, 63}, + LowToHighBits<uint64_t>(UINT64_C(0x80000000000000ff))); + CheckElements({0, 8, 16, 24, 32, 40, 48, 56, 63}, + LowToHighBits<uint64_t>(UINT64_C(0x8101010101010101))); + CheckElements({16, 17, 62, 63}, LowToHighBits<uint64_t>(UINT64_C(0xc000000000030000))); + CheckElements({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63}, + LowToHighBits<uint64_t>(UINT64_C(0xffffffffffffffff))); +} + +TEST(BitUtilsTest, TestHighToLowBits32) { + CheckElements({}, HighToLowBits<uint32_t>(0u)); + CheckElements({0}, HighToLowBits<uint32_t>(1u)); + CheckElements({15}, HighToLowBits<uint32_t>(0x8000u)); + CheckElements({31}, HighToLowBits<uint32_t>(0x80000000u)); + CheckElements({31, 0}, HighToLowBits<uint32_t>(0x80000001u)); + CheckElements({31, 7, 6, 5, 4, 3, 2, 1, 0}, HighToLowBits<uint32_t>(0x800000ffu)); + CheckElements({31, 24, 16, 8, 0}, HighToLowBits<uint32_t>(0x81010101u)); + CheckElements({31, 30, 17, 16}, HighToLowBits<uint32_t>(0xc0030000u)); + CheckElements({31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, + 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}, + HighToLowBits<uint32_t>(0xffffffffu)); +} + +TEST(BitUtilsTest, TestHighToLowBits64) { + CheckElements({}, HighToLowBits<uint64_t>(UINT64_C(0))); + CheckElements({0}, HighToLowBits<uint64_t>(UINT64_C(1))); + CheckElements({32}, HighToLowBits<uint64_t>(UINT64_C(0x100000000))); + CheckElements({63}, HighToLowBits<uint64_t>(UINT64_C(0x8000000000000000))); + CheckElements({63, 0}, HighToLowBits<uint64_t>(UINT64_C(0x8000000000000001))); + CheckElements({63, 7, 6, 5, 4, 3, 2, 1, 0}, + HighToLowBits<uint64_t>(UINT64_C(0x80000000000000ff))); + CheckElements({63, 56, 48, 40, 32, 24, 16, 8, 0}, + HighToLowBits<uint64_t>(UINT64_C(0x8101010101010101))); + CheckElements({63, 62, 17, 16}, HighToLowBits<uint64_t>(UINT64_C(0xc000000000030000))); + CheckElements({63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, + 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, + 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, + 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}, + HighToLowBits<uint64_t>(UINT64_C(0xffffffffffffffff))); +} + +} // namespace art |