unittests/ADT/BitVectorTest.cpp

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