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.all());
  23   EXPECT_TRUE(Vec.none());
  24   EXPECT_TRUE(Vec.empty());
  25
  26   Vec.resize(5, true);
  27   EXPECT_EQ(5U, Vec.count());
  28   EXPECT_EQ(5U, Vec.size());
  29   EXPECT_TRUE(Vec.any());
  30   EXPECT_TRUE(Vec.all());
  31   EXPECT_FALSE(Vec.none());
  32   EXPECT_FALSE(Vec.empty());
  33
  34   Vec.resize(11);
  35   EXPECT_EQ(5U, Vec.count());
  36   EXPECT_EQ(11U, Vec.size());
  37   EXPECT_TRUE(Vec.any());
  38   EXPECT_FALSE(Vec.all());
  39   EXPECT_FALSE(Vec.none());
  40   EXPECT_FALSE(Vec.empty());
  41
  42   SmallBitVector Inv = ~Vec;
  43   EXPECT_EQ(6U, Inv.count());
  44   EXPECT_EQ(11U, Inv.size());
  45   EXPECT_TRUE(Inv.any());
  46   EXPECT_FALSE(Inv.all());
  47   EXPECT_FALSE(Inv.none());
  48   EXPECT_FALSE(Inv.empty());
  49
  50   EXPECT_FALSE(Inv == Vec);
  51   EXPECT_TRUE(Inv != Vec);
  52   Vec = ~Vec;
  53   EXPECT_TRUE(Inv == Vec);
  54   EXPECT_FALSE(Inv != Vec);
  55
  56   // Add some "interesting" data to Vec.
  57   Vec.resize(23, true);
  58   Vec.resize(25, false);
  59   Vec.resize(26, true);
  60   Vec.resize(29, false);
  61   Vec.resize(33, true);
  62   Vec.resize(57, false);
  63   unsigned Count = 0;
  64   for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
  65     ++Count;
  66     EXPECT_TRUE(Vec[i]);
  67     EXPECT_TRUE(Vec.test(i));
  68   }
  69   EXPECT_EQ(Count, Vec.count());
  70   EXPECT_EQ(Count, 23u);
  71   EXPECT_FALSE(Vec[0]);
  72   EXPECT_TRUE(Vec[32]);
  73   EXPECT_FALSE(Vec[56]);
  74   Vec.resize(61, false);
  75
  76   SmallBitVector Copy = Vec;
  77   SmallBitVector Alt(3, false);
  78   Alt.resize(6, true);
  79   std::swap(Alt, Vec);
  80   EXPECT_TRUE(Copy == Alt);
  81   EXPECT_TRUE(Vec.size() == 6);
  82   EXPECT_TRUE(Vec.count() == 3);
  83   EXPECT_TRUE(Vec.find_first() == 3);
  84   std::swap(Copy, Vec);
  85
  86   // Add some more "interesting" data.
  87   Vec.resize(68, true);
  88   Vec.resize(78, false);
  89   Vec.resize(89, true);
  90   Vec.resize(90, false);
  91   Vec.resize(91, true);
  92   Vec.resize(130, false);
  93   Count = 0;
  94   for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
  95     ++Count;
  96     EXPECT_TRUE(Vec[i]);
  97     EXPECT_TRUE(Vec.test(i));
  98   }
  99   EXPECT_EQ(Count, Vec.count());
 100   EXPECT_EQ(Count, 42u);
 101   EXPECT_FALSE(Vec[0]);
 102   EXPECT_TRUE(Vec[32]);
 103   EXPECT_FALSE(Vec[60]);
 104   EXPECT_FALSE(Vec[129]);
 105
 106   Vec.flip(60);
 107   EXPECT_TRUE(Vec[60]);
 108   EXPECT_EQ(Count + 1, Vec.count());
 109   Vec.flip(60);
 110   EXPECT_FALSE(Vec[60]);
 111   EXPECT_EQ(Count, Vec.count());
 112
 113   Vec.reset(32);
 114   EXPECT_FALSE(Vec[32]);
 115   EXPECT_EQ(Count - 1, Vec.count());
 116   Vec.set(32);
 117   EXPECT_TRUE(Vec[32]);
 118   EXPECT_EQ(Count, Vec.count());
 119
 120   Vec.flip();
 121   EXPECT_EQ(Vec.size() - Count, Vec.count());
 122
 123   Vec.reset();
 124   EXPECT_EQ(0U, Vec.count());
 125   EXPECT_EQ(130U, Vec.size());
 126   EXPECT_FALSE(Vec.any());
 127   EXPECT_FALSE(Vec.all());
 128   EXPECT_TRUE(Vec.none());
 129   EXPECT_FALSE(Vec.empty());
 130
 131   Inv = ~SmallBitVector();
 132   EXPECT_EQ(0U, Inv.count());
 133   EXPECT_EQ(0U, Inv.size());
 134   EXPECT_FALSE(Inv.any());
 135   EXPECT_TRUE(Inv.all());
 136   EXPECT_TRUE(Inv.none());
 137   EXPECT_TRUE(Inv.empty());
 138
 139   Vec.clear();
 140   EXPECT_EQ(0U, Vec.count());
 141   EXPECT_EQ(0U, Vec.size());
 142   EXPECT_FALSE(Vec.any());
 143   EXPECT_TRUE(Vec.all());
 144   EXPECT_TRUE(Vec.none());
 145   EXPECT_TRUE(Vec.empty());
 146 }
 147
 148 TEST(SmallBitVectorTest, CompoundAssignment) {
 149   SmallBitVector A;
 150   A.resize(10);
 151   A.set(4);
 152   A.set(7);
 153
 154   SmallBitVector B;
 155   B.resize(50);
 156   B.set(5);
 157   B.set(18);
 158
 159   A |= B;
 160   EXPECT_TRUE(A.test(4));
 161   EXPECT_TRUE(A.test(5));
 162   EXPECT_TRUE(A.test(7));
 163   EXPECT_TRUE(A.test(18));
 164   EXPECT_EQ(4U, A.count());
 165   EXPECT_EQ(50U, A.size());
 166
 167   B.resize(10);
 168   B.set();
 169   B.reset(2);
 170   B.reset(7);
 171   A &= B;
 172   EXPECT_FALSE(A.test(2));
 173   EXPECT_FALSE(A.test(7));
 174   EXPECT_EQ(2U, A.count());
 175   EXPECT_EQ(50U, A.size());
 176
 177   B.resize(100);
 178   B.set();
 179
 180   A ^= B;
 181   EXPECT_TRUE(A.test(2));
 182   EXPECT_TRUE(A.test(7));
 183   EXPECT_EQ(98U, A.count());
 184   EXPECT_EQ(100U, A.size());
 185 }
 186
 187 TEST(SmallBitVectorTest, ProxyIndex) {
 188   SmallBitVector Vec(3);
 189   EXPECT_TRUE(Vec.none());
 190   Vec[0] = Vec[1] = Vec[2] = true;
 191   EXPECT_EQ(Vec.size(), Vec.count());
 192   Vec[2] = Vec[1] = Vec[0] = false;
 193   EXPECT_TRUE(Vec.none());
 194 }
 195
 196 }