unittests/ADT/SmallBitVectorTest.cpp

   1 //===- llvm/unittest/ADT/SmallBitVectorTest.cpp - SmallBitVector tests ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/SmallBitVector.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16
  17 TEST(SmallBitVectorTest, TrivialOperation) {
  18   SmallBitVector Vec;
  19   EXPECT_EQ(0U, Vec.count());
  20   EXPECT_EQ(0U, Vec.size());
  21   EXPECT_FALSE(Vec.any());
  22   EXPECT_TRUE(Vec.none());
  23   EXPECT_TRUE(Vec.empty());
  24
  25   Vec.resize(5, true);
  26   EXPECT_EQ(5U, Vec.count());
  27   EXPECT_EQ(5U, Vec.size());
  28   EXPECT_TRUE(Vec.any());
  29   EXPECT_FALSE(Vec.none());
  30   EXPECT_FALSE(Vec.empty());
  31
  32   Vec.resize(11);
  33   EXPECT_EQ(5U, Vec.count());
  34   EXPECT_EQ(11U, Vec.size());
  35   EXPECT_TRUE(Vec.any());
  36   EXPECT_FALSE(Vec.none());
  37   EXPECT_FALSE(Vec.empty());
  38
  39   SmallBitVector Inv = ~Vec;
  40   EXPECT_EQ(6U, Inv.count());
  41   EXPECT_EQ(11U, Inv.size());
  42   EXPECT_TRUE(Inv.any());
  43   EXPECT_FALSE(Inv.none());
  44   EXPECT_FALSE(Inv.empty());
  45
  46   EXPECT_FALSE(Inv == Vec);
  47   EXPECT_TRUE(Inv != Vec);
  48   Vec = ~Vec;
  49   EXPECT_TRUE(Inv == Vec);
  50   EXPECT_FALSE(Inv != Vec);
  51
  52   // Add some "interesting" data to Vec.
  53   Vec.resize(23, true);
  54   Vec.resize(25, false);
  55   Vec.resize(26, true);
  56   Vec.resize(29, false);
  57   Vec.resize(33, true);
  58   Vec.resize(61, false);
  59   unsigned Count = 0;
  60   for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
  61     ++Count;
  62     EXPECT_TRUE(Vec[i]);
  63     EXPECT_TRUE(Vec.test(i));
  64   }
  65   EXPECT_EQ(Count, Vec.count());
  66   EXPECT_EQ(Count, 23u);
  67   EXPECT_FALSE(Vec[0]);
  68   EXPECT_TRUE(Vec[32]);
  69   EXPECT_FALSE(Vec[60]);
  70
  71   SmallBitVector Copy = Vec;
  72   SmallBitVector Alt(3, false);
  73   Alt.resize(6, true);
  74   std::swap(Alt, Vec);
  75   EXPECT_TRUE(Copy == Alt);
  76   EXPECT_TRUE(Vec.size() == 6);
  77   EXPECT_TRUE(Vec.count() == 3);
  78   EXPECT_TRUE(Vec.find_first() == 3);
  79   std::swap(Copy, Vec);
  80
  81   // Add some more "interesting" data.
  82   Vec.resize(68, true);
  83   Vec.resize(78, false);
  84   Vec.resize(89, true);
  85   Vec.resize(90, false);
  86   Vec.resize(91, true);
  87   Vec.resize(130, false);
  88   Count = 0;
  89   for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
  90     ++Count;
  91     EXPECT_TRUE(Vec[i]);
  92     EXPECT_TRUE(Vec.test(i));
  93   }
  94   EXPECT_EQ(Count, Vec.count());
  95   EXPECT_EQ(Count, 42u);
  96   EXPECT_FALSE(Vec[0]);
  97   EXPECT_TRUE(Vec[32]);
  98   EXPECT_FALSE(Vec[60]);
  99   EXPECT_FALSE(Vec[129]);
 100
 101   Vec.flip(60);
 102   EXPECT_TRUE(Vec[60]);
 103   EXPECT_EQ(Count + 1, Vec.count());
 104   Vec.flip(60);
 105   EXPECT_FALSE(Vec[60]);
 106   EXPECT_EQ(Count, Vec.count());
 107
 108   Vec.reset(32);
 109   EXPECT_FALSE(Vec[32]);
 110   EXPECT_EQ(Count - 1, Vec.count());
 111   Vec.set(32);
 112   EXPECT_TRUE(Vec[32]);
 113   EXPECT_EQ(Count, Vec.count());
 114
 115   Vec.flip();
 116   EXPECT_EQ(Vec.size() - Count, Vec.count());
 117
 118   Vec.reset();
 119   EXPECT_EQ(0U, Vec.count());
 120   EXPECT_EQ(130U, Vec.size());
 121   EXPECT_FALSE(Vec.any());
 122   EXPECT_TRUE(Vec.none());
 123   EXPECT_FALSE(Vec.empty());
 124
 125   Inv = ~SmallBitVector();
 126   EXPECT_EQ(0U, Inv.count());
 127   EXPECT_EQ(0U, Inv.size());
 128   EXPECT_FALSE(Inv.any());
 129   EXPECT_TRUE(Inv.none());
 130   EXPECT_TRUE(Inv.empty());
 131
 132   Vec.clear();
 133   EXPECT_EQ(0U, Vec.count());
 134   EXPECT_EQ(0U, Vec.size());
 135   EXPECT_FALSE(Vec.any());
 136   EXPECT_TRUE(Vec.none());
 137   EXPECT_TRUE(Vec.empty());
 138 }
 139
 140 TEST(SmallBitVectorTest, CompoundAssignment) {
 141   SmallBitVector A;
 142   A.resize(10);
 143   A.set(4);
 144   A.set(7);
 145
 146   SmallBitVector B;
 147   B.resize(50);
 148   B.set(5);
 149   B.set(18);
 150
 151   A |= B;
 152   EXPECT_TRUE(A.test(4));
 153   EXPECT_TRUE(A.test(5));
 154   EXPECT_TRUE(A.test(7));
 155   EXPECT_TRUE(A.test(18));
 156   EXPECT_EQ(A.count(), 4);
 157   EXPECT_EQ(A.size(), 50);
 158
 159   B.resize(10);
 160   B.set();
 161   B.reset(2);
 162   B.reset(7);
 163   A &= B;
 164   EXPECT_FALSE(A.test(2));
 165   EXPECT_FALSE(A.test(7));
 166   EXPECT_EQ(A.size(), 50);
 167   EXPECT_EQ(A.count(), 2);
 168
 169   B.resize(100);
 170   B.set();
 171
 172   A ^= B;
 173   EXPECT_TRUE(A.test(2));
 174   EXPECT_TRUE(A.test(7));
 175   EXPECT_EQ(A.size(), 100);
 176   EXPECT_EQ(A.count(), 98);
 177 }
 178
 179 }