More unittests for BitSet

src/common/bitset_utils.h

@@ -330,7 +330,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(const BitSetT &
 template <size_t N, typename BitsT, typename ParamT>
 BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(const BitSetT &other)
 {
-    mBits = (mBits ^ other.mBits) & Mask(N);
+    mBits = mBits ^ other.mBits;
     return *this;
 }
 
@@ -350,14 +350,14 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator&=(BitsT value)
 template <size_t N, typename BitsT, typename ParamT>
 BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(BitsT value)
 {
-    mBits |= value;
+    mBits |= value & Mask(N);
     return *this;
 }
 
 template <size_t N, typename BitsT, typename ParamT>
 BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(BitsT value)
 {
-    mBits ^= value;
+    mBits ^= value & Mask(N);
     return *this;
 }
 
@@ -399,7 +399,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set(ParamT pos, bool value
 {
     if (value)
     {
-        mBits |= Bit(pos);
+        mBits |= Bit(pos) & Mask(N);
     }
     else
     {
@@ -432,7 +432,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip()
 template <size_t N, typename BitsT, typename ParamT>
 BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip(ParamT pos)
 {
-    mBits ^= Bit(pos);
+    mBits ^= Bit(pos) & Mask(N);
     return *this;
 }
 

src/common/bitset_utils_unittest.cpp

@@ -15,6 +15,148 @@ using namespace angle;
 
 namespace
 {
+class BitSetTest : public testing::Test
+{
+  protected:
+    BitSet<12> mBits;
+};
+
+TEST_F(BitSetTest, Basic)
+{
+    EXPECT_FALSE(mBits.all());
+    EXPECT_FALSE(mBits.any());
+    EXPECT_TRUE(mBits.none());
+    EXPECT_EQ(mBits.count(), 0u);
+
+    // Set every bit to 1.
+    for (size_t i = 0; i < mBits.size(); ++i)
+    {
+        mBits.set(i);
+
+        EXPECT_EQ(mBits.all(), i + 1 == mBits.size());
+        EXPECT_TRUE(mBits.any());
+        EXPECT_FALSE(mBits.none());
+        EXPECT_EQ(mBits.count(), i + 1);
+    }
+
+    // Reset every other bit to 0.
+    for (size_t i = 0; i < mBits.size(); i += 2)
+    {
+        mBits.reset(i);
+
+        EXPECT_FALSE(mBits.all());
+        EXPECT_TRUE(mBits.any());
+        EXPECT_FALSE(mBits.none());
+        EXPECT_EQ(mBits.count(), mBits.size() - i / 2 - 1);
+    }
+
+    // Flip all bits.
+    for (size_t i = 0; i < mBits.size(); ++i)
+    {
+        mBits.flip(i);
+
+        EXPECT_FALSE(mBits.all());
+        EXPECT_TRUE(mBits.any());
+        EXPECT_FALSE(mBits.none());
+        EXPECT_EQ(mBits.count(), mBits.size() / 2 + (i % 2 == 0));
+    }
+
+    // Make sure the bit pattern is what we expect at this point.
+    for (size_t i = 0; i < mBits.size(); ++i)
+    {
+        EXPECT_EQ(mBits.test(i), i % 2 == 0);
+        EXPECT_EQ(static_cast<bool>(mBits[i]), i % 2 == 0);
+    }
+
+    // Test that flip, set and reset all bits at once work.
+    mBits.flip();
+    EXPECT_FALSE(mBits.all());
+    EXPECT_TRUE(mBits.any());
+    EXPECT_FALSE(mBits.none());
+    EXPECT_EQ(mBits.count(), mBits.size() / 2);
+
+    mBits.set();
+    EXPECT_TRUE(mBits.all());
+    EXPECT_TRUE(mBits.any());
+    EXPECT_FALSE(mBits.none());
+    EXPECT_EQ(mBits.count(), mBits.size());
+
+    mBits.reset();
+    EXPECT_FALSE(mBits.all());
+    EXPECT_FALSE(mBits.any());
+    EXPECT_TRUE(mBits.none());
+    EXPECT_EQ(mBits.count(), 0u);
+
+    // Test that out-of-bound sets don't modify the bitset
+    constexpr uint32_t kMask = (1 << 12) - 1;
+
+    EXPECT_EQ(mBits.set(12).bits() & ~kMask, 0u);
+    EXPECT_EQ(mBits.set(13).bits() & ~kMask, 0u);
+    EXPECT_EQ(mBits.flip(12).bits() & ~kMask, 0u);
+    EXPECT_EQ(mBits.flip(13).bits() & ~kMask, 0u);
+}
+
+TEST_F(BitSetTest, BitwiseOperators)
+{
+    // Use a value that has a 1 in the 12th and 13th bits, to make sure masking to exactly 12 bits
+    // does not have an off-by-one error.
+    constexpr uint32_t kSelfValue  = 0xF9E4;
+    constexpr uint32_t kOtherValue = 0x5C6A;
+
+    constexpr uint32_t kMask             = (1 << 12) - 1;
+    constexpr uint32_t kSelfMaskedValue  = kSelfValue & kMask;
+    constexpr uint32_t kOtherMaskedValue = kOtherValue & kMask;
+
+    constexpr uint32_t kShift            = 3;
+    constexpr uint32_t kSelfShiftedLeft  = kSelfMaskedValue << kShift & kMask;
+    constexpr uint32_t kSelfShiftedRight = kSelfMaskedValue >> kShift & kMask;
+
+    mBits |= kSelfValue;
+    BitSet<12> other(kOtherValue);
+    BitSet<12> anded(kSelfMaskedValue & kOtherMaskedValue);
+    BitSet<12> ored(kSelfMaskedValue | kOtherMaskedValue);
+    BitSet<12> xored(kSelfMaskedValue ^ kOtherMaskedValue);
+
+    EXPECT_EQ(mBits.bits(), kSelfMaskedValue);
+    EXPECT_EQ(other.bits(), kOtherMaskedValue);
+
+    EXPECT_EQ(mBits & other, anded);
+    EXPECT_EQ(mBits | other, ored);
+    EXPECT_EQ(mBits ^ other, xored);
+
+    EXPECT_NE(mBits, other);
+    EXPECT_NE(anded, ored);
+    EXPECT_NE(anded, xored);
+    EXPECT_NE(ored, xored);
+
+    mBits &= other;
+    EXPECT_EQ(mBits, anded);
+
+    mBits |= ored;
+    EXPECT_EQ(mBits, ored);
+
+    mBits ^= other;
+    mBits ^= anded;
+    EXPECT_EQ(mBits, BitSet<12>(kSelfValue));
+
+    EXPECT_EQ(mBits << kShift, BitSet<12>(kSelfShiftedLeft));
+    EXPECT_EQ(mBits >> kShift, BitSet<12>(kSelfShiftedRight));
+
+    mBits <<= kShift;
+    EXPECT_EQ(mBits, BitSet<12>(kSelfShiftedLeft));
+    EXPECT_EQ(mBits.bits() & ~kMask, 0u);
+
+    mBits = BitSet<12>(kSelfValue);
+    mBits >>= kShift;
+    EXPECT_EQ(mBits, BitSet<12>(kSelfShiftedRight));
+    EXPECT_EQ(mBits.bits() & ~kMask, 0u);
+
+    mBits |= kSelfMaskedValue;
+    EXPECT_EQ(mBits.bits() & ~kMask, 0u);
+    mBits ^= kOtherMaskedValue;
+    EXPECT_EQ(mBits.bits() & ~kMask, 0u);
+}
+
 class BitSetIteratorTest : public testing::Test
 {
   protected: