RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-28 22:00:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
054361e47d
llvm-mirror/unittests/ADT/CoalescingBitVectorTest.cpp
Vedant Kumar 6f84fd7763 [LiveDebugValues] Speed up removeEntryValue, NFC 
Summary:
Instead of iterating over all VarLoc IDs in removeEntryValue(), just
iterate over the interval reserved for entry value VarLocs. This changes
the iteration order, hence the test update -- otherwise this is NFC.

This appears to give an ~8.5x wall time speed-up for LiveDebugValues when
compiling sqlite3.c 3.30.1 with a Release clang (on my machine):

```
          ---User Time---   --System Time--   --User+System--   ---Wall Time--- --- Name ---
  Before: 2.5402 ( 18.8%)   0.0050 (  0.4%)   2.5452 ( 17.3%)   2.5452 ( 17.3%) Live DEBUG_VALUE analysis
   After: 0.2364 (  2.1%)   0.0034 (  0.3%)   0.2399 (  2.0%)   0.2398 (  2.0%) Live DEBUG_VALUE analysis
```

The change in removeEntryValue() is the only one that appears to affect
wall time, but for consistency (and to resolve a pending TODO), I made
the analogous changes for iterating over SpillLocKind VarLocs.

Reviewers: nikic, aprantl, jmorse, djtodoro

Subscribers: hiraditya, dexonsmith, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D80684
2020-06-01 11:02:36 -07:00

562 lines
18 KiB
C++
Raw Blame History

//=== CoalescingBitVectorTest.cpp - CoalescingBitVector unit tests --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/CoalescingBitVector.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
using UBitVec = CoalescingBitVector<unsigned>;
using U64BitVec = CoalescingBitVector<uint64_t>;
bool elementsMatch(const UBitVec &BV, std::initializer_list<unsigned> List) {
if (!std::equal(BV.begin(), BV.end(), List.begin(), List.end())) {
UBitVec::Allocator Alloc;
UBitVec Expected(Alloc);
Expected.set(List);
dbgs() << "elementsMatch:\n"
<< " Expected: ";
Expected.print(dbgs());
dbgs() << " Got: ";
BV.print(dbgs());
return false;
}
return true;
}
bool rangesMatch(iterator_range<UBitVec::const_iterator> R,
std::initializer_list<unsigned> List) {
return std::equal(R.begin(), R.end(), List.begin(), List.end());
}
TEST(CoalescingBitVectorTest, Set) {
UBitVec::Allocator Alloc;
UBitVec BV1(Alloc);
UBitVec BV2(Alloc);
BV1.set(0);
EXPECT_TRUE(BV1.test(0));
EXPECT_FALSE(BV1.test(1));
BV2.set(BV1);
EXPECT_TRUE(BV2.test(0));
}
TEST(CoalescingBitVectorTest, Count) {
UBitVec::Allocator Alloc;
UBitVec BV(Alloc);
EXPECT_EQ(BV.count(), 0u);
BV.set(0);
EXPECT_EQ(BV.count(), 1u);
BV.set({11, 12, 13, 14, 15});
EXPECT_EQ(BV.count(), 6u);
}
TEST(CoalescingBitVectorTest, ClearAndEmpty) {
UBitVec::Allocator Alloc;
UBitVec BV(Alloc);
EXPECT_TRUE(BV.empty());
BV.set(1);
EXPECT_FALSE(BV.empty());
BV.clear();
EXPECT_TRUE(BV.empty());
}
TEST(CoalescingBitVector, Copy) {
UBitVec::Allocator Alloc;
UBitVec BV1(Alloc);
BV1.set(0);
UBitVec BV2 = BV1;
EXPECT_TRUE(elementsMatch(BV1, {0}));
EXPECT_TRUE(elementsMatch(BV2, {0}));
BV2.set(5);
BV2 = BV1;
EXPECT_TRUE(elementsMatch(BV1, {0}));
EXPECT_TRUE(elementsMatch(BV2, {0}));
}
TEST(CoalescingBitVectorTest, Iterators) {
UBitVec::Allocator Alloc;
UBitVec BV(Alloc);
BV.set({0, 1, 2});
auto It = BV.begin();
EXPECT_TRUE(It == BV.begin());
EXPECT_EQ(*It, 0u);
++It;
EXPECT_EQ(*It, 1u);
++It;
EXPECT_EQ(*It, 2u);
++It;
EXPECT_TRUE(It == BV.end());
EXPECT_TRUE(BV.end() == BV.end());
It = BV.begin();
EXPECT_TRUE(It == BV.begin());
auto ItCopy = It++;
EXPECT_TRUE(ItCopy == BV.begin());
EXPECT_EQ(*ItCopy, 0u);
EXPECT_EQ(*It, 1u);
EXPECT_TRUE(elementsMatch(BV, {0, 1, 2}));
BV.set({4, 5, 6});
EXPECT_TRUE(elementsMatch(BV, {0, 1, 2, 4, 5, 6}));
BV.set(3);
EXPECT_TRUE(elementsMatch(BV, {0, 1, 2, 3, 4, 5, 6}));
BV.set(10);
EXPECT_TRUE(elementsMatch(BV, {0, 1, 2, 3, 4, 5, 6, 10}));
// Should be able to reset unset bits.
BV.reset(3);
BV.reset(3);
BV.reset(20000);
BV.set({1000, 1001, 1002});
EXPECT_TRUE(elementsMatch(BV, {0, 1, 2, 4, 5, 6, 10, 1000, 1001, 1002}));
auto It1 = BV.begin();
EXPECT_TRUE(It1 == BV.begin());
EXPECT_TRUE(++It1 == ++BV.begin());
EXPECT_TRUE(It1 != BV.begin());
EXPECT_TRUE(It1 != BV.end());
}
TEST(CoalescingBitVectorTest, Reset) {
UBitVec::Allocator Alloc;
UBitVec BV(Alloc);
BV.set(0);
EXPECT_TRUE(BV.test(0));
BV.reset(0);
EXPECT_FALSE(BV.test(0));
BV.clear();
BV.set({1, 2, 3});
BV.reset(1);
EXPECT_TRUE(elementsMatch(BV, {2, 3}));
BV.clear();
BV.set({1, 2, 3});
BV.reset(2);
EXPECT_TRUE(elementsMatch(BV, {1, 3}));
BV.clear();
BV.set({1, 2, 3});
BV.reset(3);
EXPECT_TRUE(elementsMatch(BV, {1, 2}));
}
TEST(CoalescingBitVectorTest, Comparison) {
UBitVec::Allocator Alloc;
UBitVec BV1(Alloc);
UBitVec BV2(Alloc);
// Single interval.
BV1.set({1, 2, 3});
BV2.set({1, 2, 3});
EXPECT_EQ(BV1, BV2);
EXPECT_FALSE(BV1 != BV2);
// Different number of intervals.
BV1.clear();
BV2.clear();
BV1.set({1, 2, 3});
EXPECT_NE(BV1, BV2);
// Multiple intervals.
BV1.clear();
BV2.clear();
BV1.set({1, 2, 11, 12});
BV2.set({1, 2, 11, 12});
EXPECT_EQ(BV1, BV2);
BV2.reset(1);
EXPECT_NE(BV1, BV2);
BV2.set(1);
BV2.reset(11);
EXPECT_NE(BV1, BV2);
}
// A simple implementation of set union, used to double-check the human
// "expected" answer.
void simpleUnion(UBitVec &Union, const UBitVec &LHS,
const UBitVec &RHS) {
for (unsigned Bit : LHS)
Union.test_and_set(Bit);
for (unsigned Bit : RHS)
Union.test_and_set(Bit);
}
TEST(CoalescingBitVectorTest, Union) {
UBitVec::Allocator Alloc;
// Check that after doing LHS |= RHS, LHS == Expected.
auto unionIs = [&](std::initializer_list<unsigned> LHS,
std::initializer_list<unsigned> RHS,
std::initializer_list<unsigned> Expected) {
UBitVec BV1(Alloc);
BV1.set(LHS);
UBitVec BV2(Alloc);
BV2.set(RHS);
UBitVec DoubleCheckedExpected(Alloc);
simpleUnion(DoubleCheckedExpected, BV1, BV2);
ASSERT_TRUE(elementsMatch(DoubleCheckedExpected, Expected));
BV1 |= BV2;
ASSERT_TRUE(elementsMatch(BV1, Expected));
};
// Check that "LHS |= RHS" and "RHS |= LHS" both produce the expected result.
auto testUnionSymmetrically = [&](std::initializer_list<unsigned> LHS,
std::initializer_list<unsigned> RHS,
std::initializer_list<unsigned> Expected) {
unionIs(LHS, RHS, Expected);
unionIs(RHS, LHS, Expected);
};
// Empty LHS.
testUnionSymmetrically({}, {1, 2, 3}, {1, 2, 3});
// Empty RHS.
testUnionSymmetrically({1, 2, 3}, {}, {1, 2, 3});
// Full overlap.
testUnionSymmetrically({1}, {1}, {1});
testUnionSymmetrically({1, 2, 11, 12}, {1, 2, 11, 12}, {1, 2, 11, 12});
// Sliding window: fix {2, 3, 4} as the LHS, and slide a window before/after
// it. Repeat this swapping LHS and RHS.
testUnionSymmetrically({2, 3, 4}, {1, 2, 3}, {1, 2, 3, 4});
testUnionSymmetrically({2, 3, 4}, {2, 3, 4}, {2, 3, 4});
testUnionSymmetrically({2, 3, 4}, {3, 4, 5}, {2, 3, 4, 5});
testUnionSymmetrically({1, 2, 3}, {2, 3, 4}, {1, 2, 3, 4});
testUnionSymmetrically({3, 4, 5}, {2, 3, 4}, {2, 3, 4, 5});
// Multiple overlaps, but at least one of the overlaps forces us to split an
// interval (and possibly both do). For ease of understanding, fix LHS to be
// {1, 2, 11, 12}, but vary RHS.
testUnionSymmetrically({1, 2, 11, 12}, {1}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {2}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {11}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 11}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {2, 11}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {2, 12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 2, 11}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 2, 12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 11, 12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {2, 11, 12}, {1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {0, 11, 12}, {0, 1, 2, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {3, 11, 12}, {1, 2, 3, 11, 12});
testUnionSymmetrically({1, 2, 11, 12}, {1, 11, 13}, {1, 2, 11, 12, 13});
testUnionSymmetrically({1, 2, 11, 12}, {1, 10, 11}, {1, 2, 10, 11, 12});
// Partial overlap, but the existing interval covers future overlaps.
testUnionSymmetrically({1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 6, 7},
{1, 2, 3, 4, 5, 6, 7, 8});
testUnionSymmetrically({1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 7, 8, 9},
{1, 2, 3, 4, 5, 6, 7, 8, 9});
// More partial overlaps.
testUnionSymmetrically({1, 2, 3, 4, 5}, {0, 1, 2, 4, 5, 6},
{0, 1, 2, 3, 4, 5, 6});
testUnionSymmetrically({2, 3}, {1, 2, 3, 4}, {1, 2, 3, 4});
testUnionSymmetrically({3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4});
testUnionSymmetrically({1, 2}, {1, 2, 3, 4}, {1, 2, 3, 4});
testUnionSymmetrically({0, 1}, {1, 2, 3, 4}, {0, 1, 2, 3, 4});
// Merge non-overlapping.
testUnionSymmetrically({0, 1}, {2, 3}, {0, 1, 2, 3});
testUnionSymmetrically({0, 3}, {1, 2}, {0, 1, 2, 3});
}
// A simple implementation of set intersection, used to double-check the
// human "expected" answer.
void simpleIntersection(UBitVec &Intersection, const UBitVec &LHS,
const UBitVec &RHS) {
for (unsigned Bit : LHS)
if (RHS.test(Bit))
Intersection.set(Bit);
}
TEST(CoalescingBitVectorTest, Intersection) {
UBitVec::Allocator Alloc;
// Check that after doing LHS &= RHS, LHS == Expected.
auto intersectionIs = [&](std::initializer_list<unsigned> LHS,
std::initializer_list<unsigned> RHS,
std::initializer_list<unsigned> Expected) {
UBitVec BV1(Alloc);
BV1.set(LHS);
UBitVec BV2(Alloc);
BV2.set(RHS);
UBitVec DoubleCheckedExpected(Alloc);
simpleIntersection(DoubleCheckedExpected, BV1, BV2);
ASSERT_TRUE(elementsMatch(DoubleCheckedExpected, Expected));
BV1 &= BV2;
ASSERT_TRUE(elementsMatch(BV1, Expected));
};
// Check that "LHS &= RHS" and "RHS &= LHS" both produce the expected result.
auto testIntersectionSymmetrically = [&](std::initializer_list<unsigned> LHS,
std::initializer_list<unsigned> RHS,
std::initializer_list<unsigned> Expected) {
intersectionIs(LHS, RHS, Expected);
intersectionIs(RHS, LHS, Expected);
};
// Empty case, one-element case.
testIntersectionSymmetrically({}, {}, {});
testIntersectionSymmetrically({1}, {1}, {1});
testIntersectionSymmetrically({1}, {2}, {});
// Exact overlaps cases: single overlap and multiple overlaps.
testIntersectionSymmetrically({1, 2}, {1, 2}, {1, 2});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 2, 11, 12}, {1, 2, 11, 12});
// Sliding window: fix {2, 3, 4} as the LHS, and slide a window before/after
// it.
testIntersectionSymmetrically({2, 3, 4}, {1, 2, 3}, {2, 3});
testIntersectionSymmetrically({2, 3, 4}, {2, 3, 4}, {2, 3, 4});
testIntersectionSymmetrically({2, 3, 4}, {3, 4, 5}, {3, 4});
// No overlap, but we have multiple intervals.
testIntersectionSymmetrically({1, 2, 11, 12}, {3, 4, 13, 14}, {});
// Multiple overlaps, but at least one of the overlaps forces us to split an
// interval (and possibly both do). For ease of understanding, fix LHS to be
// {1, 2, 11, 12}, but vary RHS.
testIntersectionSymmetrically({1, 2, 11, 12}, {1}, {1});
testIntersectionSymmetrically({1, 2, 11, 12}, {2}, {2});
testIntersectionSymmetrically({1, 2, 11, 12}, {11}, {11});
testIntersectionSymmetrically({1, 2, 11, 12}, {12}, {12});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 11}, {1, 11});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 12}, {1, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {2, 11}, {2, 11});
testIntersectionSymmetrically({1, 2, 11, 12}, {2, 12}, {2, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 2, 11}, {1, 2, 11});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 2, 12}, {1, 2, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 11, 12}, {1, 11, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {2, 11, 12}, {2, 11, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {0, 11, 12}, {11, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {3, 11, 12}, {11, 12});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 11, 13}, {1, 11});
testIntersectionSymmetrically({1, 2, 11, 12}, {1, 10, 11}, {1, 11});
// Partial overlap, but the existing interval covers future overlaps.
testIntersectionSymmetrically({1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 6, 7},
{2, 3, 4, 6, 7});
}
// A simple implementation of set intersection-with-complement, used to
// double-check the human "expected" answer.
void simpleIntersectionWithComplement(UBitVec &Intersection, const UBitVec &LHS,
const UBitVec &RHS) {
for (unsigned Bit : LHS)
if (!RHS.test(Bit))
Intersection.set(Bit);
}
TEST(CoalescingBitVectorTest, IntersectWithComplement) {
UBitVec::Allocator Alloc;
// Check that after doing LHS.intersectWithComplement(RHS), LHS == Expected.
auto intersectionWithComplementIs =
[&](std::initializer_list<unsigned> LHS,
std::initializer_list<unsigned> RHS,
std::initializer_list<unsigned> Expected) {
UBitVec BV1(Alloc);
BV1.set(LHS);
UBitVec BV2(Alloc);
BV2.set(RHS);
UBitVec DoubleCheckedExpected(Alloc);
simpleIntersectionWithComplement(DoubleCheckedExpected, BV1, BV2);
ASSERT_TRUE(elementsMatch(DoubleCheckedExpected, Expected));
BV1.intersectWithComplement(BV2);
ASSERT_TRUE(elementsMatch(BV1, Expected));
};
// Empty case, one-element case.
intersectionWithComplementIs({}, {}, {});
intersectionWithComplementIs({1}, {1}, {});
intersectionWithComplementIs({1}, {2}, {1});
// Exact overlaps cases: single overlap and multiple overlaps.
intersectionWithComplementIs({1, 2}, {1, 2}, {});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 2, 11, 12}, {});
// Sliding window: fix {2, 3, 4} as the LHS, and slide a window before/after
// it. Repeat this swapping LHS and RHS.
intersectionWithComplementIs({2, 3, 4}, {1, 2, 3}, {4});
intersectionWithComplementIs({2, 3, 4}, {2, 3, 4}, {});
intersectionWithComplementIs({2, 3, 4}, {3, 4, 5}, {2});
intersectionWithComplementIs({1, 2, 3}, {2, 3, 4}, {1});
intersectionWithComplementIs({3, 4, 5}, {2, 3, 4}, {5});
// No overlap, but we have multiple intervals.
intersectionWithComplementIs({1, 2, 11, 12}, {3, 4, 13, 14}, {1, 2, 11, 12});
// Multiple overlaps. For ease of understanding, fix LHS to be
// {1, 2, 11, 12}, but vary RHS.
intersectionWithComplementIs({1, 2, 11, 12}, {1}, {2, 11, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {2}, {1, 11, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {11}, {1, 2, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {12}, {1, 2, 11});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 11}, {2, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 12}, {2, 11});
intersectionWithComplementIs({1, 2, 11, 12}, {2, 11}, {1, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {2, 12}, {1, 11});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 2, 11}, {12});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 2, 12}, {11});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 11, 12}, {2});
intersectionWithComplementIs({1, 2, 11, 12}, {2, 11, 12}, {1});
intersectionWithComplementIs({1, 2, 11, 12}, {0, 11, 12}, {1, 2});
intersectionWithComplementIs({1, 2, 11, 12}, {3, 11, 12}, {1, 2});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 11, 13}, {2, 12});
intersectionWithComplementIs({1, 2, 11, 12}, {1, 10, 11}, {2, 12});
// Partial overlap, but the existing interval covers future overlaps.
intersectionWithComplementIs({1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 6, 7},
{1, 5, 8});
}
TEST(CoalescingBitVectorTest, FindLowerBound) {
U64BitVec::Allocator Alloc;
U64BitVec BV(Alloc);
uint64_t BigNum1 = uint64_t(1) << 32;
uint64_t BigNum2 = (uint64_t(1) << 33) + 1;
EXPECT_TRUE(BV.find(BigNum1) == BV.end());
BV.set(BigNum1);
auto Find1 = BV.find(BigNum1);
EXPECT_EQ(*Find1, BigNum1);
BV.set(BigNum2);
auto Find2 = BV.find(BigNum1);
EXPECT_EQ(*Find2, BigNum1);
auto Find3 = BV.find(BigNum2);
EXPECT_EQ(*Find3, BigNum2);
BV.reset(BigNum1);
auto Find4 = BV.find(BigNum1);
EXPECT_EQ(*Find4, BigNum2);
BV.clear();
BV.set({1, 2, 3});
EXPECT_EQ(*BV.find(2), 2u);
EXPECT_EQ(*BV.find(3), 3u);
}
TEST(CoalescingBitVectorTest, AdvanceToLowerBound) {
U64BitVec::Allocator Alloc;
U64BitVec BV(Alloc);
uint64_t BigNum1 = uint64_t(1) << 32;
uint64_t BigNum2 = (uint64_t(1) << 33) + 1;
auto advFromBegin = [&](uint64_t To) -> U64BitVec::const_iterator {
auto It = BV.begin();
It.advanceToLowerBound(To);
return It;
};
EXPECT_TRUE(advFromBegin(BigNum1) == BV.end());
BV.set(BigNum1);
auto Find1 = advFromBegin(BigNum1);
EXPECT_EQ(*Find1, BigNum1);
BV.set(BigNum2);
auto Find2 = advFromBegin(BigNum1);
EXPECT_EQ(*Find2, BigNum1);
auto Find3 = advFromBegin(BigNum2);
EXPECT_EQ(*Find3, BigNum2);
BV.reset(BigNum1);
auto Find4 = advFromBegin(BigNum1);
EXPECT_EQ(*Find4, BigNum2);
BV.clear();
BV.set({1, 2, 3});
EXPECT_EQ(*advFromBegin(2), 2u);
EXPECT_EQ(*advFromBegin(3), 3u);
auto It = BV.begin();
It.advanceToLowerBound(0);
EXPECT_EQ(*It, 1u);
It.advanceToLowerBound(100);
EXPECT_TRUE(It == BV.end());
It.advanceToLowerBound(100);
EXPECT_TRUE(It == BV.end());
}
TEST(CoalescingBitVectorTest, HalfOpenRange) {
UBitVec::Allocator Alloc;
{
UBitVec BV(Alloc);
BV.set({1, 2, 3});
EXPECT_EQ(*BV.find(0), 1U); // find(Start) > Start
EXPECT_TRUE(rangesMatch(BV.half_open_range(0, 5), {1, 2, 3}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 4), {1, 2, 3}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 3), {1, 2}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(2, 3), {2}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(2, 4), {2, 3}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(4, 5), {}));
}
{
UBitVec BV(Alloc);
BV.set({1, 2, 11, 12});
EXPECT_TRUE(rangesMatch(BV.half_open_range(0, 15), {1, 2, 11, 12}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 13), {1, 2, 11, 12}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 12), {1, 2, 11}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(0, 5), {1, 2}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 5), {1, 2}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(2, 5), {2}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(1, 2), {1}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(13, 14), {}));
EXPECT_TRUE(rangesMatch(BV.half_open_range(2, 10), {2}));
}
{
UBitVec BV(Alloc);
BV.set({1});
EXPECT_EQ(*BV.find(0), 1U); // find(Start) == End
EXPECT_TRUE(rangesMatch(BV.half_open_range(0, 1), {}));
}
{
UBitVec BV(Alloc);
BV.set({5});
EXPECT_EQ(*BV.find(3), 5U); // find(Start) > End
EXPECT_TRUE(rangesMatch(BV.half_open_range(3, 4), {}));
}
}
TEST(CoalescingBitVectorTest, Print) {
std::string S;
{
raw_string_ostream OS(S);
UBitVec::Allocator Alloc;
UBitVec BV(Alloc);
BV.set({1});
BV.print(OS);
BV.clear();
BV.set({1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20});
BV.print(OS);
}
EXPECT_EQ(S, "{[1]}"
"{[1][11, 20]}");
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink