194 строки
6.1 KiB
C++
194 строки
6.1 KiB
C++
// Copyright (c) 2019 Google Inc.
|
|
//
|
|
// 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 "source/util/bitutils.h"
|
|
|
|
#include "gmock/gmock.h"
|
|
|
|
namespace spvtools {
|
|
namespace utils {
|
|
namespace {
|
|
|
|
using BitUtilsTest = ::testing::Test;
|
|
|
|
TEST(BitUtilsTest, MutateBitsWholeWord) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t max_u32 = ~0;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 0, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 0, false), max_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 32, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 32, true), max_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 32, true), max_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 32, false), zero_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsLow) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~0;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 1, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 1, true), one_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 1, true), max_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 32, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 1, true), one_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 1, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 3, true), uint32_t(7));
|
|
EXPECT_EQ(MutateBits(uint32_t(7), 0, 2, false), uint32_t(4));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsHigh) {
|
|
const uint8_t zero_u8 = 0;
|
|
const uint8_t one_u8 = 1;
|
|
const uint8_t max_u8 = 255;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u8, 7, 0, true), zero_u8);
|
|
EXPECT_EQ(MutateBits(zero_u8, 7, 1, true), uint8_t(128));
|
|
EXPECT_EQ(MutateBits(one_u8, 7, 1, true), uint8_t(129));
|
|
EXPECT_EQ(MutateBits(max_u8, 7, 1, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 7, 1, false), uint8_t(127));
|
|
EXPECT_EQ(MutateBits(max_u8, 6, 2, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 6, 2, false), uint8_t(63));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsUint8Mid) {
|
|
const uint8_t zero_u8 = 0;
|
|
const uint8_t max_u8 = 255;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u8, 1, 2, true), uint8_t(6));
|
|
EXPECT_EQ(MutateBits(max_u8, 1, 2, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 1, 2, false), uint8_t(0xF9));
|
|
EXPECT_EQ(MutateBits(zero_u8, 2, 3, true), uint8_t(0x1C));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsUint64Mid) {
|
|
const uint64_t zero_u64 = 0;
|
|
const uint64_t max_u64 = ~zero_u64;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u64, 1, 2, true), uint64_t(6));
|
|
EXPECT_EQ(MutateBits(max_u64, 1, 2, true), max_u64);
|
|
EXPECT_EQ(MutateBits(max_u64, 1, 2, false), uint64_t(0xFFFFFFFFFFFFFFF9));
|
|
EXPECT_EQ(MutateBits(zero_u64, 2, 3, true), uint64_t(0x000000000000001C));
|
|
EXPECT_EQ(MutateBits(zero_u64, 2, 35, true), uint64_t(0x0000001FFFFFFFFC));
|
|
EXPECT_EQ(MutateBits(zero_u64, 36, 4, true), uint64_t(0x000000F000000000));
|
|
EXPECT_EQ(MutateBits(max_u64, 36, 4, false), uint64_t(0xFFFFFF0FFFFFFFFF));
|
|
}
|
|
|
|
TEST(BitUtilsTest, SetHighBitsUint32) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~zero_u32;
|
|
|
|
EXPECT_EQ(SetHighBits(zero_u32, 0), zero_u32);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 1), 0x80000000);
|
|
EXPECT_EQ(SetHighBits(one_u32, 1), 0x80000001);
|
|
EXPECT_EQ(SetHighBits(one_u32, 2), 0xC0000001);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 31), 0xFFFFFFFE);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 32), max_u32);
|
|
EXPECT_EQ(SetHighBits(max_u32, 32), max_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, ClearHighBitsUint32) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~zero_u32;
|
|
|
|
EXPECT_EQ(ClearHighBits(zero_u32, 0), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(zero_u32, 1), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 1), one_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 31), one_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 32), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 0), max_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 1), 0x7FFFFFFF);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 2), 0x3FFFFFFF);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 31), one_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 32), zero_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionZero) {
|
|
const uint32_t zero_u32 = 0;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u32, i));
|
|
}
|
|
|
|
const uint8_t zero_u8 = 0;
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u8, i));
|
|
}
|
|
|
|
const uint64_t zero_u64 = 0;
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u64, i));
|
|
}
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionOne) {
|
|
const uint32_t one_u32 = 1;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
if (i == 0) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(one_u32, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(one_u32, i));
|
|
}
|
|
}
|
|
|
|
const uint32_t two_to_17_u32 = 1 << 17;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
if (i == 17) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_17_u32, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_17_u32, i));
|
|
}
|
|
}
|
|
|
|
const uint8_t two_to_4_u8 = 1 << 4;
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
if (i == 4) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_4_u8, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_4_u8, i));
|
|
}
|
|
}
|
|
|
|
const uint64_t two_to_55_u64 = uint64_t(1) << 55;
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
if (i == 55) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_55_u64, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_55_u64, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionAll) {
|
|
const uint32_t max_u32 = ~0;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u32, i));
|
|
}
|
|
|
|
const uint32_t max_u8 = ~uint8_t(0);
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u8, i));
|
|
}
|
|
|
|
const uint64_t max_u64 = ~uint64_t(0);
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u64, i));
|
|
}
|
|
}
|
|
} // namespace
|
|
} // namespace utils
|
|
} // namespace spvtools
|