1 //===- llvm/unittest/ADT/BitVectorTest.cpp - BitVector tests --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Some of these tests fail on PowerPC for unknown reasons.
13 #include "llvm/ADT/BitVector.h"
14 #include "llvm/ADT/SmallBitVector.h"
15 #include "gtest/gtest.h"
23 class BitVectorTest : public ::testing::Test { };
25 // Test both BitVector and SmallBitVector with the same suite of tests.
26 typedef ::testing::Types<BitVector, SmallBitVector> BitVectorTestTypes;
27 TYPED_TEST_CASE(BitVectorTest, BitVectorTestTypes);
29 TYPED_TEST(BitVectorTest, TrivialOperation) {
31 EXPECT_EQ(0U, Vec.count());
32 EXPECT_EQ(0U, Vec.size());
33 EXPECT_FALSE(Vec.any());
34 EXPECT_TRUE(Vec.all());
35 EXPECT_TRUE(Vec.none());
36 EXPECT_TRUE(Vec.empty());
39 EXPECT_EQ(5U, Vec.count());
40 EXPECT_EQ(5U, Vec.size());
41 EXPECT_TRUE(Vec.any());
42 EXPECT_TRUE(Vec.all());
43 EXPECT_FALSE(Vec.none());
44 EXPECT_FALSE(Vec.empty());
47 EXPECT_EQ(5U, Vec.count());
48 EXPECT_EQ(11U, Vec.size());
49 EXPECT_TRUE(Vec.any());
50 EXPECT_FALSE(Vec.all());
51 EXPECT_FALSE(Vec.none());
52 EXPECT_FALSE(Vec.empty());
56 EXPECT_EQ(6U, Inv.count());
57 EXPECT_EQ(11U, Inv.size());
58 EXPECT_TRUE(Inv.any());
59 EXPECT_FALSE(Inv.all());
60 EXPECT_FALSE(Inv.none());
61 EXPECT_FALSE(Inv.empty());
63 EXPECT_FALSE(Inv == Vec);
64 EXPECT_TRUE(Inv != Vec);
66 EXPECT_TRUE(Inv == Vec);
67 EXPECT_FALSE(Inv != Vec);
69 // Add some "interesting" data to Vec.
71 Vec.resize(25, false);
73 Vec.resize(29, false);
75 Vec.resize(57, false);
77 for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
80 EXPECT_TRUE(Vec.test(i));
82 EXPECT_EQ(Count, Vec.count());
83 EXPECT_EQ(Count, 23u);
86 EXPECT_FALSE(Vec[56]);
87 Vec.resize(61, false);
90 TypeParam Alt(3, false);
93 EXPECT_TRUE(Copy == Alt);
94 EXPECT_TRUE(Vec.size() == 6);
95 EXPECT_TRUE(Vec.count() == 3);
96 EXPECT_TRUE(Vec.find_first() == 3);
99 // Add some more "interesting" data.
100 Vec.resize(68, true);
101 Vec.resize(78, false);
102 Vec.resize(89, true);
103 Vec.resize(90, false);
104 Vec.resize(91, true);
105 Vec.resize(130, false);
107 for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) {
110 EXPECT_TRUE(Vec.test(i));
112 EXPECT_EQ(Count, Vec.count());
113 EXPECT_EQ(Count, 42u);
114 EXPECT_FALSE(Vec[0]);
115 EXPECT_TRUE(Vec[32]);
116 EXPECT_FALSE(Vec[60]);
117 EXPECT_FALSE(Vec[129]);
120 EXPECT_TRUE(Vec[60]);
121 EXPECT_EQ(Count + 1, Vec.count());
123 EXPECT_FALSE(Vec[60]);
124 EXPECT_EQ(Count, Vec.count());
127 EXPECT_FALSE(Vec[32]);
128 EXPECT_EQ(Count - 1, Vec.count());
130 EXPECT_TRUE(Vec[32]);
131 EXPECT_EQ(Count, Vec.count());
134 EXPECT_EQ(Vec.size() - Count, Vec.count());
137 EXPECT_EQ(0U, Vec.count());
138 EXPECT_EQ(130U, Vec.size());
139 EXPECT_FALSE(Vec.any());
140 EXPECT_FALSE(Vec.all());
141 EXPECT_TRUE(Vec.none());
142 EXPECT_FALSE(Vec.empty());
144 Inv = TypeParam().flip();
145 EXPECT_EQ(0U, Inv.count());
146 EXPECT_EQ(0U, Inv.size());
147 EXPECT_FALSE(Inv.any());
148 EXPECT_TRUE(Inv.all());
149 EXPECT_TRUE(Inv.none());
150 EXPECT_TRUE(Inv.empty());
153 EXPECT_EQ(0U, Vec.count());
154 EXPECT_EQ(0U, Vec.size());
155 EXPECT_FALSE(Vec.any());
156 EXPECT_TRUE(Vec.all());
157 EXPECT_TRUE(Vec.none());
158 EXPECT_TRUE(Vec.empty());
161 TYPED_TEST(BitVectorTest, CompoundAssignment) {
173 EXPECT_TRUE(A.test(4));
174 EXPECT_TRUE(A.test(5));
175 EXPECT_TRUE(A.test(7));
176 EXPECT_TRUE(A.test(18));
177 EXPECT_EQ(4U, A.count());
178 EXPECT_EQ(50U, A.size());
185 EXPECT_FALSE(A.test(2));
186 EXPECT_FALSE(A.test(7));
187 EXPECT_EQ(2U, A.count());
188 EXPECT_EQ(50U, A.size());
194 EXPECT_TRUE(A.test(2));
195 EXPECT_TRUE(A.test(7));
196 EXPECT_EQ(98U, A.count());
197 EXPECT_EQ(100U, A.size());
200 TYPED_TEST(BitVectorTest, ProxyIndex) {
202 EXPECT_TRUE(Vec.none());
203 Vec[0] = Vec[1] = Vec[2] = true;
204 EXPECT_EQ(Vec.size(), Vec.count());
205 Vec[2] = Vec[1] = Vec[0] = false;
206 EXPECT_TRUE(Vec.none());
209 TYPED_TEST(BitVectorTest, PortableBitMask) {
211 const uint32_t Mask1[] = { 0x80000000, 6, 5 };
214 A.setBitsInMask(Mask1, 3);
215 EXPECT_EQ(10u, A.size());
216 EXPECT_FALSE(A.test(0));
219 A.setBitsInMask(Mask1, 3);
220 EXPECT_FALSE(A.test(0));
221 EXPECT_TRUE(A.test(31));
222 EXPECT_EQ(1u, A.count());
225 A.setBitsInMask(Mask1, 1);
226 EXPECT_EQ(1u, A.count());
227 A.setBitsInMask(Mask1, 2);
228 EXPECT_EQ(1u, A.count());
231 A.setBitsInMask(Mask1, 2);
232 EXPECT_EQ(2u, A.count());
235 A.setBitsInMask(Mask1, 3);
236 EXPECT_EQ(4u, A.count());
238 A.setBitsNotInMask(Mask1, 1);
239 EXPECT_EQ(32u+3u, A.count());
241 A.setBitsNotInMask(Mask1, 3);
242 EXPECT_EQ(65u, A.count());
245 EXPECT_EQ(65u, A.count());
249 A.setBitsNotInMask(Mask1, 3);
250 EXPECT_EQ(96u-5u, A.count());
252 A.clearBitsNotInMask(Mask1, 1);
253 EXPECT_EQ(64-4u, A.count());
256 TYPED_TEST(BitVectorTest, BinOps) {
261 EXPECT_FALSE(A.anyCommon(B));
262 EXPECT_FALSE(B.anyCommon(B));
266 EXPECT_FALSE(A.anyCommon(B));
267 EXPECT_FALSE(B.anyCommon(A));
270 EXPECT_FALSE(A.anyCommon(B));
271 EXPECT_FALSE(B.anyCommon(A));
274 EXPECT_TRUE(A.anyCommon(B));
275 EXPECT_TRUE(B.anyCommon(A));
281 EXPECT_FALSE(A.anyCommon(B));
282 EXPECT_FALSE(B.anyCommon(A));
285 TYPED_TEST(BitVectorTest, RangeOps) {
291 EXPECT_FALSE(A.test(0));
292 EXPECT_TRUE( A.test(1));
293 EXPECT_TRUE( A.test(23));
294 EXPECT_TRUE( A.test(254));
295 EXPECT_FALSE(A.test(255));
302 EXPECT_TRUE( B.test(0));
303 EXPECT_FALSE(B.test(1));
304 EXPECT_FALSE(B.test(23));
305 EXPECT_FALSE(B.test(254));
306 EXPECT_TRUE( B.test(255));
313 EXPECT_TRUE(C.test(0));
314 EXPECT_FALSE( C.test(1));
315 EXPECT_FALSE( C.test(2));
322 EXPECT_FALSE(D.test(0));
323 EXPECT_TRUE( D.test(1));
324 EXPECT_TRUE( D.test(2));