static void doTestDgaps(int32_t size, int32_t count1, int32_t count2)
{
DirectoryPtr d = newLucene<RAMDirectory>();
BitVectorPtr bv = newLucene<BitVector>(size);
for (int32_t i = 0; i < count1; ++i)
{
bv->set(i);
BOOST_CHECK_EQUAL(i + 1, bv->count());
}
bv->write(d, L"TESTBV");
// gradually increase number of set bits
for (int32_t i = count1; i < count2; ++i)
{
BitVectorPtr bv2 = newLucene<BitVector>(d, L"TESTBV");
BOOST_CHECK(compareBitVectors(bv, bv2));
bv = bv2;
bv->set(i);
BOOST_CHECK_EQUAL(i + 1, bv->count());
bv->write(d, L"TESTBV");
}
// now start decreasing number of set bits
for (int32_t i = count2 - 1; i >= count1; --i)
{
BitVectorPtr bv2 = newLucene<BitVector>(d, L"TESTBV");
BOOST_CHECK(compareBitVectors(bv, bv2));
bv = bv2;
bv->clear(i);
BOOST_CHECK_EQUAL(i, bv->count());
bv->write(d, L"TESTBV");
}
}
BitVectorPtr VLC_HuffmanEncoder::transitData(ByteVecotrPtr src)
{
BitVectorPtr ret = BitVectorPtr(new BitVector());
for (ByteVecotr::iterator it = src->begin(); it != src->end(); it++)
{
unordered_map<stKey, shared_ptr<typeTreeNode>>::iterator got = leafMap.find(*it);
if (got == leafMap.end())
{
return NULL;
}
else
{
shared_ptr<typeTreeNode> leaf = got->second;
huffmanTree.setCurrentPos(leaf);
BitVector bits;
while (!huffmanTree.IsRoot())
{
bits.push_back(huffmanTree.GetCurrentData().Symbol);
huffmanTree.Parent();
}
for (BitVector::size_type i = 0; i < bits.size(); i++)
{
ret->push_back(bits[bits.size() - 1 - i]);
}
}
}
return ret;
}
static void doTestGetSetVectorOfSize(int32_t n)
{
BitVectorPtr bv = newLucene<BitVector>(n);
for (int32_t i = 0; i < bv->size(); ++i)
{
BOOST_CHECK(!bv->get(i));
bv->set(i);
BOOST_CHECK(bv->get(i));
}
}
static bool compareBitVectors(BitVectorPtr bv, BitVectorPtr compare)
{
for (int32_t i = 0; i < bv->size(); ++i)
{
// bits must be equal
if (bv->get(i) != compare->get(i))
return false;
}
return true;
}
static BitVectorPtr createSubsetTestVector()
{
int32_t length = SIZEOF_ARRAY(subsetPattern);
BitVectorPtr bv = newLucene<BitVector>(length);
for (int32_t i = 0; i < length; ++i)
{
if (subsetPattern[i] == 1)
bv->set(i);
}
return bv;
}
ByteVecotrPtr VLC_HuffmanDecoder::transitData(BitVectorPtr src)
{
ByteVecotrPtr ret = ByteVecotrPtr(new ByteVecotr());
ret->clear();
huffmanTree->Root();
for (BitVector::size_type i = 0; i < src->size(); i++ )
{
bool bit = (*src)[i];
if (!bit)
{
huffmanTree->FirstChild();
}
else
{
huffmanTree->FirstChild();
huffmanTree->NextSibling();
}
if (huffmanTree->IsLeaf())
{
stKey val = huffmanTree->GetCurrentData().GrayScale;
ret->push_back(val);
huffmanTree->Root();
}
}
return ret;
}
static void doTestWriteRead(int32_t n)
{
DirectoryPtr d = newLucene<RAMDirectory>();
BitVectorPtr bv = newLucene<BitVector>(n);
// test count when incrementally setting bits
for (int32_t i = 0; i < bv->size(); ++i)
{
BOOST_CHECK(!bv->get(i));
BOOST_CHECK_EQUAL(i, bv->count());
bv->set(i);
BOOST_CHECK(bv->get(i));
BOOST_CHECK_EQUAL(i + 1, bv->count());
bv->write(d, L"TESTBV");
BitVectorPtr compare = newLucene<BitVector>(d, L"TESTBV");
// compare bit vectors with bits set incrementally
BOOST_CHECK(compareBitVectors(bv, compare));
}
}
/// Compare a subset against the corresponding portion of the test pattern
static void doTestSubset(int32_t start, int32_t end)
{
BitVectorPtr full = createSubsetTestVector();
BitVectorPtr subset = full->subset(start, end);
BOOST_CHECK_EQUAL(end - start, subset->size());
int32_t count = 0;
for (int32_t i = start, j = 0; i < end; ++i, ++j)
{
if (subsetPattern[i] == 1)
{
++count;
BOOST_CHECK(subset->get(j));
}
else
BOOST_CHECK(!subset->get(j));
}
BOOST_CHECK_EQUAL(count, subset->count());
}
static void doTestCountVectorOfSize(int32_t n)
{
BitVectorPtr bv = newLucene<BitVector>(n);
// test count when incrementally setting bits
for (int32_t i = 0; i < bv->size(); ++i)
{
BOOST_CHECK(!bv->get(i));
BOOST_CHECK_EQUAL(i, bv->count());
bv->set(i);
BOOST_CHECK(bv->get(i));
BOOST_CHECK_EQUAL(i + 1, bv->count());
}
bv = newLucene<BitVector>(n);
// test count when setting then clearing bits
for (int32_t i = 0; i < bv->size(); ++i)
{
BOOST_CHECK(!bv->get(i));
BOOST_CHECK_EQUAL(0, bv->count());
bv->set(i);
BOOST_CHECK(bv->get(i));
BOOST_CHECK_EQUAL(1, bv->count());
bv->clear(i);
BOOST_CHECK(!bv->get(i));
BOOST_CHECK_EQUAL(0, bv->count());
}
}
static void doTestConstructOfSize(int32_t n)
{
BitVectorPtr bv = newLucene<BitVector>(n);
BOOST_CHECK_EQUAL(n, bv->size());
}
