X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=unittests%2FADT%2FBitVectorTest.cpp;h=3deaff0fe3569b447451a95ebea6bd162614f1a7;hb=be031d9158aa3fbc87a5f9e2c1b4b74a414cd0b6;hp=fa663121a8a690110528dd27d8a2afc54a2b9c1e;hpb=fab4c9e9df1aeb33b55cfcfa174fac8d61df96fd;p=oota-llvm.git diff --git a/unittests/ADT/BitVectorTest.cpp b/unittests/ADT/BitVectorTest.cpp index fa663121a8a..3deaff0fe35 100644 --- a/unittests/ADT/BitVectorTest.cpp +++ b/unittests/ADT/BitVectorTest.cpp @@ -11,14 +11,23 @@ #ifndef __ppc__ #include "llvm/ADT/BitVector.h" +#include "llvm/ADT/SmallBitVector.h" #include "gtest/gtest.h" using namespace llvm; namespace { -TEST(BitVectorTest, TrivialOperation) { - BitVector Vec; +// Test fixture +template +class BitVectorTest : public ::testing::Test { }; + +// Test both BitVector and SmallBitVector with the same suite of tests. +typedef ::testing::Types BitVectorTestTypes; +TYPED_TEST_CASE(BitVectorTest, BitVectorTestTypes); + +TYPED_TEST(BitVectorTest, TrivialOperation) { + TypeParam Vec; EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(0U, Vec.size()); EXPECT_FALSE(Vec.any()); @@ -42,7 +51,8 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_FALSE(Vec.none()); EXPECT_FALSE(Vec.empty()); - BitVector Inv = ~Vec; + TypeParam Inv = Vec; + Inv.flip(); EXPECT_EQ(6U, Inv.count()); EXPECT_EQ(11U, Inv.size()); EXPECT_TRUE(Inv.any()); @@ -52,7 +62,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_FALSE(Inv == Vec); EXPECT_TRUE(Inv != Vec); - Vec = ~Vec; + Vec.flip(); EXPECT_TRUE(Inv == Vec); EXPECT_FALSE(Inv != Vec); @@ -76,8 +86,8 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_FALSE(Vec[56]); Vec.resize(61, false); - BitVector Copy = Vec; - BitVector Alt(3, false); + TypeParam Copy = Vec; + TypeParam Alt(3, false); Alt.resize(6, true); std::swap(Alt, Vec); EXPECT_TRUE(Copy == Alt); @@ -131,7 +141,31 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_TRUE(Vec.none()); EXPECT_FALSE(Vec.empty()); - Inv = ~BitVector(); + Vec.flip(); + EXPECT_EQ(130U, Vec.count()); + EXPECT_EQ(130U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_TRUE(Vec.all()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Vec.resize(64); + EXPECT_EQ(64U, Vec.count()); + EXPECT_EQ(64U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_TRUE(Vec.all()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Vec.flip(); + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(64U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_FALSE(Vec.all()); + EXPECT_TRUE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Inv = TypeParam().flip(); EXPECT_EQ(0U, Inv.count()); EXPECT_EQ(0U, Inv.size()); EXPECT_FALSE(Inv.any()); @@ -148,13 +182,13 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_TRUE(Vec.empty()); } -TEST(BitVectorTest, CompoundAssignment) { - BitVector A; +TYPED_TEST(BitVectorTest, CompoundAssignment) { + TypeParam A; A.resize(10); A.set(4); A.set(7); - BitVector B; + TypeParam B; B.resize(50); B.set(5); B.set(18); @@ -187,8 +221,8 @@ TEST(BitVectorTest, CompoundAssignment) { EXPECT_EQ(100U, A.size()); } -TEST(BitVectorTest, ProxyIndex) { - BitVector Vec(3); +TYPED_TEST(BitVectorTest, ProxyIndex) { + TypeParam Vec(3); EXPECT_TRUE(Vec.none()); Vec[0] = Vec[1] = Vec[2] = true; EXPECT_EQ(Vec.size(), Vec.count()); @@ -196,6 +230,174 @@ TEST(BitVectorTest, ProxyIndex) { EXPECT_TRUE(Vec.none()); } +TYPED_TEST(BitVectorTest, PortableBitMask) { + TypeParam A; + const uint32_t Mask1[] = { 0x80000000, 6, 5 }; + + A.resize(10); + A.setBitsInMask(Mask1, 3); + EXPECT_EQ(10u, A.size()); + EXPECT_FALSE(A.test(0)); + + A.resize(32); + A.setBitsInMask(Mask1, 3); + EXPECT_FALSE(A.test(0)); + EXPECT_TRUE(A.test(31)); + EXPECT_EQ(1u, A.count()); + + A.resize(33); + A.setBitsInMask(Mask1, 1); + EXPECT_EQ(1u, A.count()); + A.setBitsInMask(Mask1, 2); + EXPECT_EQ(1u, A.count()); + + A.resize(34); + A.setBitsInMask(Mask1, 2); + EXPECT_EQ(2u, A.count()); + + A.resize(65); + A.setBitsInMask(Mask1, 3); + EXPECT_EQ(4u, A.count()); + + A.setBitsNotInMask(Mask1, 1); + EXPECT_EQ(32u+3u, A.count()); + + A.setBitsNotInMask(Mask1, 3); + EXPECT_EQ(65u, A.count()); + + A.resize(96); + EXPECT_EQ(65u, A.count()); + + A.clear(); + A.resize(128); + A.setBitsNotInMask(Mask1, 3); + EXPECT_EQ(96u-5u, A.count()); + + A.clearBitsNotInMask(Mask1, 1); + EXPECT_EQ(64-4u, A.count()); } +TYPED_TEST(BitVectorTest, BinOps) { + TypeParam A; + TypeParam B; + + A.resize(65); + EXPECT_FALSE(A.anyCommon(B)); + EXPECT_FALSE(B.anyCommon(B)); + + B.resize(64); + A.set(64); + EXPECT_FALSE(A.anyCommon(B)); + EXPECT_FALSE(B.anyCommon(A)); + + B.set(63); + EXPECT_FALSE(A.anyCommon(B)); + EXPECT_FALSE(B.anyCommon(A)); + + A.set(63); + EXPECT_TRUE(A.anyCommon(B)); + EXPECT_TRUE(B.anyCommon(A)); + + B.resize(70); + B.set(64); + B.reset(63); + A.resize(64); + EXPECT_FALSE(A.anyCommon(B)); + EXPECT_FALSE(B.anyCommon(A)); +} + +TYPED_TEST(BitVectorTest, RangeOps) { + TypeParam A; + A.resize(256); + A.reset(); + A.set(1, 255); + + EXPECT_FALSE(A.test(0)); + EXPECT_TRUE( A.test(1)); + EXPECT_TRUE( A.test(23)); + EXPECT_TRUE( A.test(254)); + EXPECT_FALSE(A.test(255)); + + TypeParam B; + B.resize(256); + B.set(); + B.reset(1, 255); + + EXPECT_TRUE( B.test(0)); + EXPECT_FALSE(B.test(1)); + EXPECT_FALSE(B.test(23)); + EXPECT_FALSE(B.test(254)); + EXPECT_TRUE( B.test(255)); + + TypeParam C; + C.resize(3); + C.reset(); + C.set(0, 1); + + EXPECT_TRUE(C.test(0)); + EXPECT_FALSE( C.test(1)); + EXPECT_FALSE( C.test(2)); + + TypeParam D; + D.resize(3); + D.set(); + D.reset(0, 1); + + EXPECT_FALSE(D.test(0)); + EXPECT_TRUE( D.test(1)); + EXPECT_TRUE( D.test(2)); + + TypeParam E; + E.resize(128); + E.reset(); + E.set(1, 33); + + EXPECT_FALSE(E.test(0)); + EXPECT_TRUE( E.test(1)); + EXPECT_TRUE( E.test(32)); + EXPECT_FALSE(E.test(33)); + + TypeParam BufferOverrun; + unsigned size = sizeof(unsigned long) * 8; + BufferOverrun.resize(size); + BufferOverrun.reset(0, size); + BufferOverrun.set(0, size); +} + +TYPED_TEST(BitVectorTest, CompoundTestReset) { + TypeParam A(50, true); + TypeParam B(50, false); + + TypeParam C(100, true); + TypeParam D(100, false); + + EXPECT_FALSE(A.test(A)); + EXPECT_TRUE(A.test(B)); + EXPECT_FALSE(A.test(C)); + EXPECT_TRUE(A.test(D)); + EXPECT_FALSE(B.test(A)); + EXPECT_FALSE(B.test(B)); + EXPECT_FALSE(B.test(C)); + EXPECT_FALSE(B.test(D)); + EXPECT_TRUE(C.test(A)); + EXPECT_TRUE(C.test(B)); + EXPECT_FALSE(C.test(C)); + EXPECT_TRUE(C.test(D)); + + A.reset(B); + A.reset(D); + EXPECT_TRUE(A.all()); + A.reset(A); + EXPECT_TRUE(A.none()); + A.set(); + A.reset(C); + EXPECT_TRUE(A.none()); + A.set(); + + C.reset(A); + EXPECT_EQ(50, C.find_first()); + C.reset(C); + EXPECT_TRUE(C.none()); +} +} #endif