github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

2010-02-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Removed unused methods from BitfieldMan class.  Moved
	getFirstMissingIndex to bitfield.h. Updated doc for BitfieldMan
	class.
	* src/BitfieldMan.cc
	* src/BitfieldMan.h
	* src/BitfieldManFactory.cc
	* src/BitfieldManFactory.h
	* src/bitfield.h
	* src/main.cc
	* test/BitfieldManTest.cc
	* test/DefaultPieceStorageTest.cc
pull/1/head
Tatsuhiro Tsujikawa 2010-02-11 08:22:37 +00:00
parent e3e3f0438d
commit b89e306599
9 changed files with 99 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ChangeLog
View File

@ -1,3 +1,17 @@
2010-02-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Removed unused methods from BitfieldMan class. Moved
getFirstMissingIndex to bitfield.h. Updated doc for BitfieldMan
class.
* src/BitfieldMan.cc
* src/BitfieldMan.h
* src/BitfieldManFactory.cc
* src/BitfieldManFactory.h
* src/bitfield.h
* src/main.cc
* test/BitfieldManTest.cc
* test/DefaultPieceStorageTest.cc
2010-02-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Moved getFirstNMissingIndex to bitfield.h and made it return the

138
src/BitfieldMan.cc
View File

@ -37,7 +37,6 @@
#include <cassert>
#include <cstring>
#include "Randomizer.h"
#include "util.h"
#include "array_fun.h"
#include "bitfield.h"
@ -81,7 +80,6 @@ BitfieldMan::BitfieldMan(const BitfieldMan& bitfieldMan)
bitfield(new unsigned char[bitfieldLength]),
useBitfield(new unsigned char[bitfieldLength]),
filterBitfield(0),
randomizer(bitfieldMan.randomizer),
cachedNumMissingBlock(0),
cachedNumFilteredBlock(0),
cachedCompletedLength(0),
@ -144,51 +142,9 @@ size_t BitfieldMan::getBlockLength(size_t index) const
}
}
size_t
BitfieldMan::getNthBitIndex(const unsigned char bitfield, size_t nth) const
bool BitfieldMan::hasMissingPiece
(const unsigned char* peerBitfield, size_t length) const
{
size_t index = 0;
for(int bs = 7; bs >= 0; --bs) {
unsigned char mask = 1 << bs;
if(bitfield & mask) {
nth--;
if(nth == 0) {
index = 7-bs;
break;
}
}
}
return index;
}
template<typename Array>
bool BitfieldMan::getMissingIndexRandomly(size_t& index,
const Array& bitfield,
size_t bitfieldLength) const
{
size_t byte = randomizer->getRandomNumber(bitfieldLength);
for(size_t i = 0; i < bitfieldLength; ++i) {
unsigned char mask;
if(byte == bitfieldLength-1) {
mask = bitfield::lastByteMask(blocks);
} else {
mask = 0xff;
}
unsigned char bits = bitfield[byte];
if(bits&mask) {
index = byte*8+getNthBitIndex(bits, 1);
return true;
}
++byte;
if(byte == bitfieldLength) {
byte = 0;
}
}
return false;
}
bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) {
return false;
}
@ -206,65 +162,15 @@ bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, size_t leng
return retval;
}
bool BitfieldMan::getMissingIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) {
return false;
}
if(filterEnabled) {
return getMissingIndexRandomly
(index,
~array(bitfield)&array(peerBitfield)&array(filterBitfield),
bitfieldLength);
} else {
return getMissingIndexRandomly
(index, ~array(bitfield)&array(peerBitfield), bitfieldLength);
}
}
bool BitfieldMan::getMissingUnusedIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) {
return false;
}
if(filterEnabled) {
return getMissingIndexRandomly
(index,
~array(bitfield)&~array(useBitfield)&array(peerBitfield)&array(filterBitfield),
bitfieldLength);
} else {
return getMissingIndexRandomly
(index,
~array(bitfield)&~array(useBitfield)&array(peerBitfield),
bitfieldLength);
}
}
template<typename Array>
bool BitfieldMan::getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const
{
for(size_t i = 0; i < bitfieldLength; ++i) {
unsigned char bits = bitfield[i];
unsigned char mask = 128;
size_t tindex = i*8;
for(size_t bi = 0; bi < 8 && tindex < blocks; ++bi, mask >>= 1, ++tindex) {
if(bits & mask) {
index = tindex;
return true;
}
}
}
return false;
}
bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const
{
if(filterEnabled) {
return getFirstMissingIndex
return bitfield::getFirstMissingIndex
(index, ~array(bitfield)&~array(useBitfield)&array(filterBitfield),
bitfieldLength);
blocks);
} else {
return getFirstMissingIndex
(index, ~array(bitfield)&~array(useBitfield),
bitfieldLength);
return bitfield::getFirstMissingIndex
(index, ~array(bitfield)&~array(useBitfield), blocks);
}
}
@ -285,31 +191,10 @@ size_t BitfieldMan::getFirstNMissingUnusedIndex
bool BitfieldMan::getFirstMissingIndex(size_t& index) const
{
if(filterEnabled) {
return getFirstMissingIndex(index, ~array(bitfield)&array(filterBitfield),
bitfieldLength);
return bitfield::getFirstMissingIndex
(index, ~array(bitfield)&array(filterBitfield), blocks);
} else {
return getFirstMissingIndex(index, ~array(bitfield), bitfieldLength);
}
}
bool BitfieldMan::getMissingIndex(size_t& index) const {
if(filterEnabled) {
return getMissingIndexRandomly
(index, ~array(bitfield)&array(filterBitfield), bitfieldLength);
} else {
return getMissingIndexRandomly(index, ~array(bitfield), bitfieldLength);
}
}
bool BitfieldMan::getMissingUnusedIndex(size_t& index) const
{
if(filterEnabled) {
return getMissingIndexRandomly
(index, ~array(bitfield)&~array(useBitfield)&array(filterBitfield),
bitfieldLength);
} else {
return getMissingIndexRandomly
(index, ~array(bitfield)&~array(useBitfield), bitfieldLength);
return bitfield::getFirstMissingIndex(index, ~array(bitfield), blocks);
}
}
@ -797,9 +682,4 @@ uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
return length;
}
void BitfieldMan::setRandomizer(const SharedHandle<Randomizer>& randomizer)
{
this->randomizer = randomizer;
}
} // namespace aria2

138
src/BitfieldMan.h
View File

@ -42,8 +42,6 @@
namespace aria2 {
class Randomizer;
class BitfieldMan {
private:
size_t blockLength;
@ -54,7 +52,6 @@ private:
unsigned char* bitfield;
unsigned char* useBitfield;
unsigned char* filterBitfield;
SharedHandle<Randomizer> randomizer;
// for caching
size_t cachedNumMissingBlock;
@ -63,20 +60,6 @@ private:
uint64_t cachedFilteredComletedLength;
uint64_t cachedFilteredTotalLength;
size_t getNthBitIndex(const unsigned char bit, size_t nth) const;
bool getMissingIndexRandomly(size_t& index, const unsigned char* bitfield, size_t len) const;
template<typename Array>
bool getMissingIndexRandomly(size_t& index, const Array& bitfield,
size_t bitfieldLength) const;
template<typename Array>
bool getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const;
template<typename Array>
bool getAllMissingIndexes(std::deque<size_t>& indexes,
const Array& bitfield,
size_t bitfieldLength) const;
bool setBitInternal(unsigned char* bitfield, size_t index, bool on);
bool setFilterBit(size_t index);
@ -130,72 +113,53 @@ public:
uint64_t getTotalLength() const { return totalLength; }
/**
* affected by filter
*/
// Returns true iff there is a bit index which is set in bitfield,
// but not set in this object.
//
// affected by filter
bool hasMissingPiece(const unsigned char* bitfield, size_t len) const;
/**
* affected by filter
*/
bool getMissingIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
/**
* affected by filter
*/
bool getMissingIndex(size_t& index) const;
/**
* affected by filter
*/
// affected by filter
bool getFirstMissingUnusedIndex(size_t& index) const;
/**
* Appends at most n missing unused index to out. This function
* doesn't delete existing elements in out. Returns the number of
* appended elements.
*
* affected by filter
*/
// Appends at most n missing unused index to out. This function
// doesn't delete existing elements in out. Returns the number of
// appended elements.
//
// affected by filter
size_t getFirstNMissingUnusedIndex(std::vector<size_t>& out, size_t n) const;
/**
* affected by filter
*/
// Stores first missing bit index to index. Returns true if such bit
// index is found. Otherwise returns false.
//
// affected by filter
bool getFirstMissingIndex(size_t& index) const;
/**
* affected by filter
*/
bool getMissingUnusedIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
/**
* affected by filter
*/
bool getMissingUnusedIndex(size_t& index) const;
/**
* affected by filter
*/
// Stores missing bit index to index. index is selected so that it
// divides longest missing bit subarray into 2 equally sized
// subarray. Set bits in ignoreBitfield are excluded. Returns true
// if such bit index is found. Otherwise returns false.
//
// affected by filter
bool getSparseMissingUnusedIndex
(size_t& index,
const unsigned char* ignoreBitfield,
size_t ignoreBitfieldLength) const;
/**
* affected by filter
*/
// affected by filter
bool getAllMissingIndexes(unsigned char* misbitfield, size_t mislen) const;
/**
* affected by filter
*/
// affected by filter
bool getAllMissingIndexes(unsigned char* misbitfield, size_t mislen,
const unsigned char* bitfield, size_t len) const;
/**
* affected by filter
*/
// affected by filter
bool getAllMissingUnusedIndexes(unsigned char* misbitfield, size_t mislen,
const unsigned char* bitfield,
size_t len) const;
/**
* affected by filter
*/
// affected by filter
size_t countMissingBlock() const;
/**
* affected by filter
*/
// affected by filter
size_t countMissingBlockNow() const;
bool setUseBit(size_t index);
@ -207,9 +171,7 @@ public:
bool isBitSet(size_t index) const;
bool isUseBitSet(size_t index) const;
/**
* affected by filter
*/
// affected by filter
bool isFilteredAllBitSet() const;
bool isAllBitSet() const;
@ -226,9 +188,7 @@ public:
return bitfieldLength;
}
/**
* affected by filter
*/
// affected by filter
size_t countFilteredBlock() const
{
return cachedNumFilteredBlock;
@ -239,9 +199,7 @@ public:
return blocks;
}
/**
* affected by filter
*/
// affected by filter
size_t countFilteredBlockNow() const;
size_t getMaxIndex() const
@ -262,9 +220,7 @@ public:
// Add filter not in the range of [offset, offset+length) bytes
void addNotFilter(uint64_t offset, uint64_t length);
/**
* Clears filter and disables filter
*/
// Clears filter and disables filter
void clearFilter();
void enableFilter();
@ -274,17 +230,13 @@ public:
return filterEnabled;
}
/**
* affected by filter
*/
// affected by filter
uint64_t getFilteredTotalLength() const
{
return cachedFilteredTotalLength;
}
/**
* affected by filter
*/
// affected by filter
uint64_t getFilteredTotalLengthNow() const;
uint64_t getCompletedLength() const
@ -294,25 +246,15 @@ public:
uint64_t getCompletedLengthNow() const;
/**
* affected by filter
*/
// affected by filter
uint64_t getFilteredCompletedLength() const
{
return cachedFilteredComletedLength;
}
/**
* affected by filter
*/
// affected by filter
uint64_t getFilteredCompletedLengthNow() const;
void setRandomizer(const SharedHandle<Randomizer>& randomizer);
const SharedHandle<Randomizer>& getRandomizer() const
{
return randomizer;
}
void updateCache();
bool isBitRangeSet(size_t startIndex, size_t endIndex) const;

22
src/BitfieldManFactory.cc
View File

@ -34,7 +34,6 @@
/* copyright --> */
#include "BitfieldManFactory.h"
#include "BitfieldMan.h"
#include "Randomizer.h"
namespace aria2 {
@ -56,28 +55,7 @@ BitfieldMan*
BitfieldManFactory::createBitfieldMan(size_t blockLength, uint64_t totalLength)
{
BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength);
bitfieldMan->setRandomizer(randomizer);
return bitfieldMan;
}
void BitfieldManFactory::setDefaultRandomizer(const RandomizerHandle& randomizer) {
BitfieldManFactoryHandle factory = getFactoryInstance();
factory->setRandomizer(randomizer);
}
RandomizerHandle BitfieldManFactory::getDefaultRandomizer()
{
return getFactoryInstance()->getRandomizer();
}
void BitfieldManFactory::setRandomizer(const RandomizerHandle& randomizer)
{
this->randomizer = randomizer;
}
RandomizerHandle BitfieldManFactory::getRandomizer() const
{
return randomizer;
}
} // namespace aria2

10
src/BitfieldManFactory.h
View File

@ -47,8 +47,6 @@ class BitfieldManFactory {
private:
static SharedHandle<BitfieldManFactory> factory;
SharedHandle<Randomizer> randomizer;
BitfieldManFactory();
public:
~BitfieldManFactory();
@ -56,14 +54,6 @@ public:
static SharedHandle<BitfieldManFactory> getFactoryInstance();
BitfieldMan* createBitfieldMan(size_t blockLength, uint64_t totalLength);
static void setDefaultRandomizer(const SharedHandle<Randomizer>& randomizer);
static SharedHandle<Randomizer> getDefaultRandomizer();
void setRandomizer(const SharedHandle<Randomizer>& randomizer);
SharedHandle<Randomizer> getRandomizer() const;
};
typedef SharedHandle<BitfieldManFactory> BitfieldManFactoryHandle;

21
src/bitfield.h
View File

@ -118,6 +118,27 @@ inline size_t countSetBit(const unsigned char* bitfield, size_t nbits)
void flipBit(unsigned char* data, size_t length, size_t bitIndex);
// Stores first missing bit index of bitfield to index. bitfield
// contains nbits. Returns true if missing bit index is
// found. Otherwise returns false.
template<typename Array>
bool getFirstMissingIndex
(size_t& index, const Array& bitfield, size_t nbits)
{
const size_t bitfieldLength = (nbits+7)/8;
for(size_t i = 0; i < bitfieldLength; ++i) {
unsigned char mask = 128;
size_t tindex = i*8;
for(size_t bi = 0; bi < 8 && tindex < nbits; ++bi, mask >>= 1, ++tindex) {
if(bitfield[i] & mask) {
index = tindex;
return true;
}
}
}
return false;
}
// Appends first at most n set bit index in bitfield to out. bitfield
// contains nbits bits. Returns the number of appended bit indexes.
template<typename Array, typename OutputIterator>

1
src/main.cc
View File

@ -173,7 +173,6 @@ downloadresultcode::RESULT main(int argc, char* argv[])
option_processing(*op.get(), args, argc, argv);
SimpleRandomizer::init();
BitfieldManFactory::setDefaultRandomizer(SimpleRandomizer::getInstance());
#ifdef ENABLE_BITTORRENT
bittorrent::generateStaticPeerId(op->get(PREF_PEER_ID_PREFIX));
#endif // ENABLE_BITTORRENT

303
test/BitfieldManTest.cc
View File

@ -5,8 +5,8 @@
#include <cppunit/extensions/HelperMacros.h>
#include "FixedNumberRandomizer.h"
#include "bitfield.h"
#include "array_fun.h"
namespace aria2 {
@ -22,7 +22,6 @@ class BitfieldManTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testAddNotFilter);
CPPUNIT_TEST(testAddNotFilter_zeroLength);
CPPUNIT_TEST(testAddNotFilter_overflow);
CPPUNIT_TEST(testGetMissingIndex);
CPPUNIT_TEST(testGetSparceMissingUnusedIndex);
CPPUNIT_TEST(testGetSparceMissingUnusedIndex_setBit);
CPPUNIT_TEST(testIsBitSetOffsetRange);
@ -32,34 +31,15 @@ class BitfieldManTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testGetAllMissingIndexes_noarg);
CPPUNIT_TEST(testGetAllMissingIndexes_checkLastByte);
CPPUNIT_TEST(testGetAllMissingUnusedIndexes);
CPPUNIT_TEST(testGetMissingUnusedIndex);
CPPUNIT_TEST(testGetMissingIndex_noarg);
CPPUNIT_TEST(testGetMissingUnusedIndex_noarg);
CPPUNIT_TEST(testCountFilteredBlock);
CPPUNIT_TEST(testCountMissingBlock);
CPPUNIT_TEST(testZeroLengthFilter);
CPPUNIT_TEST(testGetFirstNMissingUnusedIndex);
CPPUNIT_TEST_SUITE_END();
private:
SharedHandle<Randomizer> fixedNumberRandomizer;
public:
BitfieldManTest() {
FixedNumberRandomizer* randomizer = new FixedNumberRandomizer();
randomizer->setFixedNumber(0);
this->fixedNumberRandomizer.reset(randomizer);
}
void setUp() {
}
void testGetBlockSize();
void testGetFirstMissingUnusedIndex();
void testGetFirstMissingIndex();
void testGetMissingIndex();
void testGetMissingIndex_noarg();
void testGetMissingUnusedIndex();
void testGetMissingUnusedIndex_noarg();
void testGetAllMissingIndexes();
void testGetAllMissingIndexes_noarg();
void testGetAllMissingIndexes_checkLastByte();
@ -201,116 +181,6 @@ void BitfieldManTest::testGetFirstMissingIndex()
}
}
void BitfieldManTest::testGetMissingUnusedIndex_noarg()
{
{
BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.unsetUseBit(0);
bt1.setBit(0);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit();
{
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer);
bt1.addFilter(1024, 1024*10);
bt1.enableFilter();
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
bt1.setBit(2);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
}
}
}
void BitfieldManTest::testGetMissingIndex_noarg()
{
{
BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.unsetUseBit(0);
bt1.setBit(0);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit();
{
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer);
bt1.addFilter(1024, 1024*10);
bt1.enableFilter();
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setBit(1);
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
}
}
void BitfieldManTest::testIsAllBitSet() {
BitfieldMan bt1(1024, 1024*10);
CPPUNIT_ASSERT(!bt1.isAllBitSet());
@ -331,53 +201,32 @@ void BitfieldManTest::testIsAllBitSet() {
CPPUNIT_ASSERT(btzero.isAllBitSet());
}
void BitfieldManTest::testFilter() {
void BitfieldManTest::testFilter()
{
BitfieldMan btman(2, 32);
btman.setRandomizer(fixedNumberRandomizer);
// test offset=4, length=12
btman.addFilter(4, 12);
btman.enableFilter();
unsigned char peerBt[2];
memset(peerBt, 0xff, sizeof(peerBt));
size_t index;
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
std::vector<size_t> out;
CPPUNIT_ASSERT_EQUAL((size_t)6, btman.getFirstNMissingUnusedIndex(out, 32));
const size_t ans[] = { 2, 3, 4, 5, 6, 7 };
for(size_t i = 0; i < arrayLength(ans); ++i) {
CPPUNIT_ASSERT_EQUAL(ans[i], out[i]);
}
CPPUNIT_ASSERT_EQUAL((uint64_t)12ULL, btman.getFilteredTotalLength());
// test offset=5, length=2
out.clear();
btman.clearAllBit();
btman.clearAllUseBit();
btman.clearFilter();
btman.addFilter(5, 2);
btman.enableFilter();
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
btman.setBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
btman.setBit(index);
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
CPPUNIT_ASSERT_EQUAL((size_t)2, btman.getFirstNMissingUnusedIndex(out, 32));
CPPUNIT_ASSERT_EQUAL((size_t)2, out[0]);
CPPUNIT_ASSERT_EQUAL((size_t)3, out[1]);
btman.setBit(2);
btman.setBit(3);
CPPUNIT_ASSERT_EQUAL((uint64_t)4ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
@ -385,7 +234,6 @@ void BitfieldManTest::testFilter() {
btman2.addFilter(0, 31);
btman2.enableFilter();
CPPUNIT_ASSERT_EQUAL((uint64_t)31ULL, btman2.getFilteredTotalLength());
}
void BitfieldManTest::testAddFilter_zeroLength()
@ -426,73 +274,6 @@ void BitfieldManTest::testAddNotFilter_overflow() {
CPPUNIT_ASSERT(bitfield::test(btman.getFilterBitfield(), 3, 2));
}
void BitfieldManTest::testGetMissingIndex() {
BitfieldMan bt1(1024, 1024*256);
bt1.setRandomizer(fixedNumberRandomizer);
unsigned char bitArray[] = {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bt1.addFilter(1024, 1024*256);
bt1.enableFilter();
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bt1.disableFilter();
unsigned char bitArray2[] = {
0x0f, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray2, 32));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
unsigned char bitArray3[] = {
0x00, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray3, 32));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
unsigned char bitArray4[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
}
// TODO1.5 add test using ignoreBitfield
void BitfieldManTest::testGetSparceMissingUnusedIndex() {
BitfieldMan bitfield(1024*1024, 10*1024*1024);
@ -761,60 +542,6 @@ void BitfieldManTest::testGetAllMissingUnusedIndexes()
CPPUNIT_ASSERT(bitfield::test(misbitfield, nbits, 63));
}
void BitfieldManTest::testGetMissingUnusedIndex()
{
BitfieldMan bt1(1024, 1024*256);
bt1.setRandomizer(fixedNumberRandomizer);
size_t index;
{
unsigned char bitArray[] = {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bt1.addFilter(1024, 1024*256);
bt1.enableFilter();
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bt1.setUseBit(1);
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bt1.disableFilter();
bt1.setBit(0);
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bt1.setAllBit();
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
bt1.clearAllBit();
bt1.setAllUseBit();
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
}
{
unsigned char bitArray4[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray4, 32));
}
}
void BitfieldManTest::testCountFilteredBlock()
{
BitfieldMan bt(1024, 1024*256);

8
test/DefaultPieceStorageTest.cc
View File

@ -4,7 +4,6 @@
#include "util.h"
#include "Exception.h"
#include "FixedNumberRandomizer.h"
#include "BitfieldManFactory.h"
#include "Piece.h"
#include "Peer.h"
@ -40,13 +39,6 @@ private:
Option* option;
SharedHandle<PieceSelector> _pieceSelector;
public:
DefaultPieceStorageTest() {
SharedHandle<FixedNumberRandomizer> randomizer
(new FixedNumberRandomizer());
randomizer->setFixedNumber(0);
BitfieldManFactory::setDefaultRandomizer(randomizer);
}
void setUp() {
_dctx.reset(new DownloadContext());
bittorrent::load("test.torrent", _dctx);