namespace {
-// Test fixture
-class PointerIntPairTest : public testing::Test {
-};
+TEST(PointerIntPairTest, GetSet) {
+ struct S {
+ int i;
+ };
+ S s;
-TEST_F(PointerIntPairTest, GetSet) {
- PointerIntPair<PointerIntPairTest *, 2> Pair{this, 1U};
- EXPECT_EQ(this, Pair.getPointer());
+ PointerIntPair<S *, 2> Pair(&s, 1U);
+ EXPECT_EQ(&s, Pair.getPointer());
EXPECT_EQ(1U, Pair.getInt());
Pair.setInt(2);
- EXPECT_EQ(this, Pair.getPointer());
+ EXPECT_EQ(&s, Pair.getPointer());
EXPECT_EQ(2U, Pair.getInt());
Pair.setPointer(nullptr);
EXPECT_EQ(nullptr, Pair.getPointer());
EXPECT_EQ(2U, Pair.getInt());
- Pair.setPointerAndInt(this, 3U);
- EXPECT_EQ(this, Pair.getPointer());
+ Pair.setPointerAndInt(&s, 3U);
+ EXPECT_EQ(&s, Pair.getPointer());
EXPECT_EQ(3U, Pair.getInt());
+
+ // Make sure that we can perform all of our operations on enum classes.
+ //
+ // The concern is that enum classes are only explicitly convertible to
+ // integers. This means that if we assume in PointerIntPair this, a
+ // compilation error will result. This group of tests exercises the enum class
+ // code to make sure that we do not run into such issues in the future.
+ enum class E : unsigned {
+ Case1,
+ Case2,
+ Case3,
+ };
+ PointerIntPair<S *, 2, E> Pair2(&s, E::Case1);
+ EXPECT_EQ(&s, Pair2.getPointer());
+ EXPECT_EQ(E::Case1, Pair2.getInt());
+
+ Pair2.setInt(E::Case2);
+ EXPECT_EQ(&s, Pair2.getPointer());
+ EXPECT_EQ(E::Case2, Pair2.getInt());
+
+ Pair2.setPointer(nullptr);
+ EXPECT_EQ(nullptr, Pair2.getPointer());
+ EXPECT_EQ(E::Case2, Pair2.getInt());
+
+ Pair2.setPointerAndInt(&s, E::Case3);
+ EXPECT_EQ(&s, Pair2.getPointer());
+ EXPECT_EQ(E::Case3, Pair2.getInt());
}
-TEST_F(PointerIntPairTest, DefaultInitialize) {
- PointerIntPair<PointerIntPairTest *, 2> Pair;
+TEST(PointerIntPairTest, DefaultInitialize) {
+ PointerIntPair<float *, 2> Pair;
EXPECT_EQ(nullptr, Pair.getPointer());
EXPECT_EQ(0U, Pair.getInt());
}
-TEST_F(PointerIntPairTest, ManyUnusedBits) {
+TEST(PointerIntPairTest, ManyUnusedBits) {
// In real code this would be a word-sized integer limited to 31 bits.
struct Fixnum31 {
uintptr_t Value;
PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits> pair;
EXPECT_EQ((uintptr_t)0, pair.getPointer().Value);
- EXPECT_EQ(false, pair.getInt());
+ EXPECT_FALSE(pair.getInt());
pair.setPointerAndInt({ 0x7FFFFFFF }, true );
EXPECT_EQ((uintptr_t)0x7FFFFFFF, pair.getPointer().Value);
- EXPECT_EQ(true, pair.getInt());
+ EXPECT_TRUE(pair.getInt());
EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);