llvm-project/llvm/unittests/ADT/BitFieldsTest.cpp

257 lines
8.4 KiB
C++

//===- llvm/unittests/ADT/BitFieldsTest.cpp - BitFields unit tests --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/Bitfields.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
TEST(BitfieldsTest, Example) {
uint8_t Storage = 0;
// Store and retrieve a single bit as bool.
using Bool = Bitfield::Element<bool, 0, 1>;
Bitfield::set<Bool>(Storage, true);
EXPECT_EQ(Storage, 0b00000001);
// ^
EXPECT_EQ(Bitfield::get<Bool>(Storage), true);
// Store and retrieve a 2 bit typed enum.
// Note: enum underlying type must be unsigned.
enum class SuitEnum : uint8_t { CLUBS, DIAMONDS, HEARTS, SPADES };
// Note: enum maximum value needs to be passed in as last parameter.
using Suit = Bitfield::Element<SuitEnum, 1, 2, SuitEnum::SPADES>;
Bitfield::set<Suit>(Storage, SuitEnum::HEARTS);
EXPECT_EQ(Storage, 0b00000101);
// ^^
EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::HEARTS);
// Store and retrieve a 5 bit value as unsigned.
using Value = Bitfield::Element<unsigned, 3, 5>;
Bitfield::set<Value>(Storage, 10);
EXPECT_EQ(Storage, 0b01010101);
// ^^^^^
EXPECT_EQ(Bitfield::get<Value>(Storage), 10U);
// Interpret the same 5 bit value as signed.
using SignedValue = Bitfield::Element<int, 3, 5>;
Bitfield::set<SignedValue>(Storage, -2);
EXPECT_EQ(Storage, 0b11110101);
// ^^^^^
EXPECT_EQ(Bitfield::get<SignedValue>(Storage), -2);
// Ability to efficiently test if a field is non zero.
EXPECT_TRUE(Bitfield::test<Value>(Storage));
// Alter Storage changes value.
Storage = 0;
EXPECT_EQ(Bitfield::get<Bool>(Storage), false);
EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::CLUBS);
EXPECT_EQ(Bitfield::get<Value>(Storage), 0U);
EXPECT_EQ(Bitfield::get<SignedValue>(Storage), 0);
Storage = 255;
EXPECT_EQ(Bitfield::get<Bool>(Storage), true);
EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::SPADES);
EXPECT_EQ(Bitfield::get<Value>(Storage), 31U);
EXPECT_EQ(Bitfield::get<SignedValue>(Storage), -1);
}
TEST(BitfieldsTest, FirstBit) {
uint8_t Storage = 0;
using FirstBit = Bitfield::Element<bool, 0, 1>;
// Set true
Bitfield::set<FirstBit>(Storage, true);
EXPECT_EQ(Bitfield::get<FirstBit>(Storage), true);
EXPECT_EQ(Storage, 0x1ULL);
// Set false
Bitfield::set<FirstBit>(Storage, false);
EXPECT_EQ(Bitfield::get<FirstBit>(Storage), false);
EXPECT_EQ(Storage, 0x0ULL);
}
TEST(BitfieldsTest, SecondBit) {
uint8_t Storage = 0;
using SecondBit = Bitfield::Element<bool, 1, 1>;
// Set true
Bitfield::set<SecondBit>(Storage, true);
EXPECT_EQ(Bitfield::get<SecondBit>(Storage), true);
EXPECT_EQ(Storage, 0x2ULL);
// Set false
Bitfield::set<SecondBit>(Storage, false);
EXPECT_EQ(Bitfield::get<SecondBit>(Storage), false);
EXPECT_EQ(Storage, 0x0ULL);
}
TEST(BitfieldsTest, LastBit) {
uint8_t Storage = 0;
using LastBit = Bitfield::Element<bool, 7, 1>;
// Set true
Bitfield::set<LastBit>(Storage, true);
EXPECT_EQ(Bitfield::get<LastBit>(Storage), true);
EXPECT_EQ(Storage, 0x80ULL);
// Set false
Bitfield::set<LastBit>(Storage, false);
EXPECT_EQ(Bitfield::get<LastBit>(Storage), false);
EXPECT_EQ(Storage, 0x0ULL);
}
TEST(BitfieldsTest, LastBitUint64) {
uint64_t Storage = 0;
using LastBit = Bitfield::Element<bool, 63, 1>;
// Set true
Bitfield::set<LastBit>(Storage, true);
EXPECT_EQ(Bitfield::get<LastBit>(Storage), true);
EXPECT_EQ(Storage, 0x8000000000000000ULL);
// Set false
Bitfield::set<LastBit>(Storage, false);
EXPECT_EQ(Bitfield::get<LastBit>(Storage), false);
EXPECT_EQ(Storage, 0x0ULL);
}
TEST(BitfieldsTest, Enum) {
enum Enum : unsigned { Zero = 0, Two = 2, LAST = Two };
uint8_t Storage = 0;
using OrderingField = Bitfield::Element<Enum, 1, 2, LAST>;
EXPECT_EQ(Bitfield::get<OrderingField>(Storage), Zero);
Bitfield::set<OrderingField>(Storage, Two);
EXPECT_EQ(Bitfield::get<OrderingField>(Storage), Two);
EXPECT_EQ(Storage, 0b00000100);
// value 2 in ^^
}
TEST(BitfieldsTest, EnumClass) {
enum class Enum : unsigned { Zero = 0, Two = 2, LAST = Two };
uint8_t Storage = 0;
using OrderingField = Bitfield::Element<Enum, 1, 2, Enum::LAST>;
EXPECT_EQ(Bitfield::get<OrderingField>(Storage), Enum::Zero);
Bitfield::set<OrderingField>(Storage, Enum::Two);
EXPECT_EQ(Bitfield::get<OrderingField>(Storage), Enum::Two);
EXPECT_EQ(Storage, 0b00000100);
// value 2 in ^^
}
TEST(BitfieldsTest, OneBitSigned) {
uint8_t Storage = 0;
using SignedField = Bitfield::Element<int, 1, 1>;
EXPECT_EQ(Bitfield::get<SignedField>(Storage), 0);
EXPECT_EQ(Storage, 0b00000000);
// value 0 in ^
Bitfield::set<SignedField>(Storage, -1);
EXPECT_EQ(Bitfield::get<SignedField>(Storage), -1);
EXPECT_EQ(Storage, 0b00000010);
// value 1 in ^
}
TEST(BitfieldsTest, TwoBitSigned) {
uint8_t Storage = 0;
using SignedField = Bitfield::Element<int, 1, 2>;
EXPECT_EQ(Bitfield::get<SignedField>(Storage), 0);
EXPECT_EQ(Storage, 0b00000000);
// value 0 in ^^
Bitfield::set<SignedField>(Storage, 1);
EXPECT_EQ(Bitfield::get<SignedField>(Storage), 1);
EXPECT_EQ(Storage, 0b00000010);
// value 1 in ^^
Bitfield::set<SignedField>(Storage, -1);
EXPECT_EQ(Bitfield::get<SignedField>(Storage), -1);
EXPECT_EQ(Storage, 0b00000110);
// value -1 in ^^
Bitfield::set<SignedField>(Storage, -2);
EXPECT_EQ(Bitfield::get<SignedField>(Storage), -2);
EXPECT_EQ(Storage, 0b00000100);
// value -2 in ^^
}
TEST(BitfieldsTest, isOverlapping) {
// 01234567
// A: --------
// B: ---
// C: ---
// D: ---
using A = Bitfield::Element<unsigned, 0, 8>;
using B = Bitfield::Element<unsigned, 3, 3>;
using C = Bitfield::Element<unsigned, 1, 3>;
using D = Bitfield::Element<unsigned, 4, 3>;
EXPECT_TRUE((Bitfield::isOverlapping<A, B>()));
EXPECT_TRUE((Bitfield::isOverlapping<A, C>()));
EXPECT_TRUE((Bitfield::isOverlapping<A, B>()));
EXPECT_TRUE((Bitfield::isOverlapping<A, D>()));
EXPECT_TRUE((Bitfield::isOverlapping<B, C>()));
EXPECT_TRUE((Bitfield::isOverlapping<B, D>()));
EXPECT_FALSE((Bitfield::isOverlapping<C, D>()));
}
TEST(BitfieldsTest, areContiguous) {
using A = Bitfield::Element<unsigned, 0, 1>; // Next Bit:1
using B = Bitfield::Element<unsigned, 1, 4>; // Next Bit:5
using C = Bitfield::Element<unsigned, 5, 3>; // Next Bit:8
EXPECT_TRUE((Bitfield::areContiguous<A, B>()));
EXPECT_TRUE((Bitfield::areContiguous<A, B, C>()));
EXPECT_FALSE((Bitfield::areContiguous<A, C>()));
EXPECT_FALSE((Bitfield::areContiguous<A, A>()));
EXPECT_FALSE((Bitfield::areContiguous<B, A>()));
}
TEST(BitfieldsTest, FullUint64) {
uint64_t Storage = 0;
using Value = Bitfield::Element<uint64_t, 0, 64>;
Bitfield::set<Value>(Storage, -1ULL);
EXPECT_EQ(Bitfield::get<Value>(Storage), -1ULL);
Bitfield::set<Value>(Storage, 0ULL);
EXPECT_EQ(Bitfield::get<Value>(Storage), 0ULL);
}
TEST(BitfieldsTest, FullInt64) {
uint64_t Storage = 0;
using Value = Bitfield::Element<int64_t, 0, 64>;
Bitfield::set<Value>(Storage, -1);
EXPECT_EQ(Bitfield::get<Value>(Storage), -1);
Bitfield::set<Value>(Storage, 0);
EXPECT_EQ(Bitfield::get<Value>(Storage), 0);
}
#ifdef EXPECT_DEBUG_DEATH
TEST(BitfieldsTest, ValueTooBigBool) {
uint64_t Storage = 0;
using A = Bitfield::Element<unsigned, 0, 1>;
Bitfield::set<A>(Storage, true);
Bitfield::set<A>(Storage, false);
EXPECT_DEBUG_DEATH(Bitfield::set<A>(Storage, 2), "value is too big");
}
TEST(BitfieldsTest, ValueTooBigInt) {
uint64_t Storage = 0;
using A = Bitfield::Element<unsigned, 0, 2>;
Bitfield::set<A>(Storage, 3);
EXPECT_DEBUG_DEATH(Bitfield::set<A>(Storage, 4), "value is too big");
EXPECT_DEBUG_DEATH(Bitfield::set<A>(Storage, -1), "value is too big");
}
TEST(BitfieldsTest, ValueTooBigBounded) {
uint8_t Storage = 0;
using A = Bitfield::Element<int, 1, 2>;
Bitfield::set<A>(Storage, 1);
Bitfield::set<A>(Storage, 0);
Bitfield::set<A>(Storage, -1);
Bitfield::set<A>(Storage, -2);
EXPECT_DEBUG_DEATH(Bitfield::set<A>(Storage, 2), "value is too big");
EXPECT_DEBUG_DEATH(Bitfield::set<A>(Storage, -3), "value is too small");
}
#endif
} // namespace