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

2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com> 

Type clarification: size_t for length or size, uint64_t for file
	length, off_t for file offset.

	* src/PiecedSegment.cc
	* src/GrowSegment.h
	* src/DefaultBtRequestFactory.h
	* src/DefaultBtProgressInfoFile.cc
	* src/UnknownLengthPieceStorage.h
	* src/DefaultPieceStorage.cc
	* src/UnknownLengthPieceStorage.cc
	* src/DefaultBtInteractive.cc
	* src/GrowSegment.cc
	* src/BitfieldMan.h
	* src/DownloadCommand.cc
	* src/BtRequestFactory.h
	* src/PiecedSegment.h
	* src/DefaultPieceStorage.h
	* src/Piece.cc
	* src/DefaultBtRequestFactory.cc
	* src/PieceStorage.h
	* src/Segment.h
	* src/Piece.h
	* src/BitfieldMan.cc
	* src/Util.cc
	* test/DefaultBtProgressInfoFileTest.cc
	* test/DefaultPieceStorageTest.cc
	* test/MockPieceStorage.h
	* test/BtRequestMessageTest.cc
	* test/DefaultBtMessageDispatcherTest.cc
	* test/BitfieldManTest.cc
	* test/GrowSegmentTest.cc
	* test/PieceTest.cc
	* test/SegmentTest.cc
	* test/SegmentManTest.cc
	* test/DefaultBtRequestFactoryTest.cc
	* test/MockBtRequestFactory.h
pull/1/head
Tatsuhiro Tsujikawa 2008-03-08 08:04:28 +00:00
parent aa669e8646
commit 518a200d57
34 changed files with 976 additions and 782 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
ChangeLog
View File

@ -1,3 +1,42 @@
2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
Type clarification: size_t for length or size, uint64_t for file
length, off_t for file offset.
* src/PiecedSegment.cc
* src/GrowSegment.h
* src/DefaultBtRequestFactory.h
* src/DefaultBtProgressInfoFile.cc
* src/UnknownLengthPieceStorage.h
* src/DefaultPieceStorage.cc
* src/UnknownLengthPieceStorage.cc
* src/DefaultBtInteractive.cc
* src/GrowSegment.cc
* src/BitfieldMan.h
* src/DownloadCommand.cc
* src/BtRequestFactory.h
* src/PiecedSegment.h
* src/DefaultPieceStorage.h
* src/Piece.cc
* src/DefaultBtRequestFactory.cc
* src/PieceStorage.h
* src/Segment.h
* src/Piece.h
* src/BitfieldMan.cc
* src/Util.cc
* test/DefaultBtProgressInfoFileTest.cc
* test/DefaultPieceStorageTest.cc
* test/MockPieceStorage.h
* test/BtRequestMessageTest.cc
* test/DefaultBtMessageDispatcherTest.cc
* test/BitfieldManTest.cc
* test/GrowSegmentTest.cc
* test/PieceTest.cc
* test/SegmentTest.cc
* test/SegmentManTest.cc
* test/DefaultBtRequestFactoryTest.cc
* test/MockBtRequestFactory.h
2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com> 2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
Fixed compilation error with --disable-nls Fixed compilation error with --disable-nls

287
src/BitfieldMan.cc
View File

@ -40,7 +40,7 @@
namespace aria2 { namespace aria2 {
BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength) BitfieldMan::BitfieldMan(size_t blockLength, uint64_t totalLength)
:blockLength(blockLength), :blockLength(blockLength),
totalLength(totalLength), totalLength(totalLength),
bitfield(0), bitfield(0),
@ -138,42 +138,45 @@ BitfieldMan::~BitfieldMan() {
delete [] filterBitfield; delete [] filterBitfield;
} }
int32_t BitfieldMan::getBlockLength() const size_t BitfieldMan::getBlockLength() const
{ {
return blockLength; return blockLength;
} }
int32_t BitfieldMan::getLastBlockLength() const size_t BitfieldMan::getLastBlockLength() const
{ {
return totalLength-blockLength*(blocks-1); return totalLength-blockLength*(blocks-1);
} }
int32_t BitfieldMan::getBlockLength(int32_t index) const size_t BitfieldMan::getBlockLength(size_t index) const
{ {
if(index == blocks-1) { if(index == blocks-1) {
return getLastBlockLength(); return getLastBlockLength();
} else if(0 <= index && index < blocks-1) { } else if(index < blocks-1) {
return getBlockLength(); return getBlockLength();
} else { } else {
return 0; return 0;
} }
} }
int32_t BitfieldMan::countSetBit(const unsigned char* bitfield, int32_t len) const { size_t BitfieldMan::countSetBit(const unsigned char* bitfield, size_t len) const {
int32_t count = 0; size_t count = 0;
int32_t size = sizeof(int32_t); size_t size = sizeof(uint32_t);
for(int32_t i = 0; i < len/size; ++i) { size_t to = len/size;
count += Util::countBit(*(uint32_t*)&bitfield[i*size]); for(size_t i = 0; i < to; ++i) {
count += Util::countBit(*reinterpret_cast<const uint32_t*>(&bitfield[i*size]));
} }
for(int32_t i = len-len%size; i < len; i++) { for(size_t i = len-len%size; i < len; i++) {
count += Util::countBit((uint32_t)bitfield[i]); count += Util::countBit(static_cast<uint32_t>(bitfield[i]));
} }
return count; return count;
} }
int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) const { size_t
int32_t index = -1; BitfieldMan::getNthBitIndex(const unsigned char bitfield, size_t nth) const
for(int bs = 7; bs >= 0; bs--) { {
size_t index = 0;
for(size_t bs = 7; bs >= 0; bs--) {
unsigned char mask = 1 << bs; unsigned char mask = 1 << bs;
if(bitfield & mask) { if(bitfield & mask) {
nth--; nth--;
@ -187,27 +190,22 @@ int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) c
} }
template<typename Array> template<typename Array>
int32_t bool BitfieldMan::getMissingIndexRandomly(size_t& index,
BitfieldMan::getMissingIndexRandomly(const Array& bitfield, const Array& bitfield,
int32_t bitfieldLength) const size_t bitfieldLength) const
{ {
/* size_t byte = randomizer->getRandomNumber(bitfieldLength);
int32_t byte = (int32_t)(((double)bitfieldLength)*
randomizer->getRandomNumber()/
(randomizer->getMaxRandomNumber()+1.0));
*/
int32_t byte = randomizer->getRandomNumber(bitfieldLength);
unsigned char lastMask = 0; unsigned char lastMask = 0;
// the number of bytes in the last byte of bitfield // the number of bytes in the last byte of bitfield
int32_t lastByteLength = totalLength%(blockLength*8); size_t lastByteLength = totalLength%(blockLength*8);
// the number of block in the last byte of bitfield // the number of block in the last byte of bitfield
int32_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength); size_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength);
for(int32_t i = 0; i < lastBlockCount; ++i) { for(size_t i = 0; i < lastBlockCount; ++i) {
lastMask >>= 1; lastMask >>= 1;
lastMask |= 0x80; lastMask |= 0x80;
} }
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
unsigned char mask; unsigned char mask;
if(byte == bitfieldLength-1) { if(byte == bitfieldLength-1) {
mask = lastMask; mask = lastMask;
@ -215,23 +213,23 @@ BitfieldMan::getMissingIndexRandomly(const Array& bitfield,
mask = 0xff; mask = 0xff;
} }
if(bitfield[byte]&mask) { if(bitfield[byte]&mask) {
int32_t index = byte*8+getNthBitIndex(bitfield[byte], 1); index = byte*8+getNthBitIndex(bitfield[byte], 1);
return index; return true;
} }
byte++; byte++;
if(byte == bitfieldLength) { if(byte == bitfieldLength) {
byte = 0; byte = 0;
} }
} }
return -1; return false;
} }
bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t length) const { bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) { if(bitfieldLength != length) {
return false; return false;
} }
bool retval = false; bool retval = false;
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
unsigned char temp = peerBitfield[i] & ~bitfield[i]; unsigned char temp = peerBitfield[i] & ~bitfield[i];
if(filterEnabled) { if(filterEnabled) {
temp &= filterBitfield[i]; temp &= filterBitfield[i];
@ -244,20 +242,20 @@ bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t len
return retval; return retval;
} }
int32_t BitfieldMan::getMissingIndex(const unsigned char* peerBitfield, int32_t length) const { bool BitfieldMan::getMissingIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) { if(bitfieldLength != length) {
return -1; return false;
} }
array_fun<unsigned char> bf = array_and(array_negate(bitfield), peerBitfield); array_fun<unsigned char> bf = array_and(array_negate(bitfield), peerBitfield);
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getMissingIndexRandomly(bf, bitfieldLength); return getMissingIndexRandomly(index, bf, bitfieldLength);
} }
int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, int32_t length) const { bool BitfieldMan::getMissingUnusedIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
if(bitfieldLength != length) { if(bitfieldLength != length) {
return -1; return false;
} }
array_fun<unsigned char> bf = array_and(array_and(array_negate(bitfield), array_fun<unsigned char> bf = array_and(array_and(array_negate(bitfield),
array_negate(useBitfield)), array_negate(useBitfield)),
@ -265,72 +263,75 @@ int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, in
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getMissingIndexRandomly(bf, bitfieldLength); return getMissingIndexRandomly(index, bf, bitfieldLength);
} }
template<typename Array> template<typename Array>
int32_t BitfieldMan::getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const bool BitfieldMan::getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const
{ {
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
int32_t base = i*8; size_t base = i*8;
for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) { for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
unsigned char mask = 128 >> bi; unsigned char mask = 128 >> bi;
if(bitfield[i] & mask) { if(bitfield[i] & mask) {
return base+bi; index = base+bi;
return true;
} }
} }
} }
return -1; return false;
} }
int32_t BitfieldMan::getFirstMissingUnusedIndex() const { bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const
{
array_fun<unsigned char> bf = array_and(array_negate(bitfield), array_fun<unsigned char> bf = array_and(array_negate(bitfield),
array_negate(useBitfield)); array_negate(useBitfield));
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getFirstMissingIndex(bf, bitfieldLength); return getFirstMissingIndex(index, bf, bitfieldLength);
} }
int32_t BitfieldMan::getFirstMissingIndex() const bool BitfieldMan::getFirstMissingIndex(size_t& index) const
{ {
array_fun<unsigned char> bf = array_negate(bitfield); array_fun<unsigned char> bf = array_negate(bitfield);
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getFirstMissingIndex(bf, bitfieldLength); return getFirstMissingIndex(index, bf, bitfieldLength);
} }
int32_t BitfieldMan::getMissingIndex() const { bool BitfieldMan::getMissingIndex(size_t& index) const {
array_fun<unsigned char> bf = array_negate(bitfield); array_fun<unsigned char> bf = array_negate(bitfield);
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getMissingIndexRandomly(bf, bitfieldLength); return getMissingIndexRandomly(index, bf, bitfieldLength);
} }
int32_t BitfieldMan::getMissingUnusedIndex() const { bool BitfieldMan::getMissingUnusedIndex(size_t& index) const
{
array_fun<unsigned char> bf = array_and(array_negate(bitfield), array_fun<unsigned char> bf = array_and(array_negate(bitfield),
array_negate(useBitfield)); array_negate(useBitfield));
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
} }
return getMissingIndexRandomly(bf, bitfieldLength); return getMissingIndexRandomly(index, bf, bitfieldLength);
} }
// [startIndex, endIndex) // [startIndex, endIndex)
class Range { class Range {
public: public:
int32_t startIndex; size_t startIndex;
int32_t endIndex; size_t endIndex;
Range(int32_t startIndex = 0, int32_t endIndex = 0):startIndex(startIndex), Range(size_t startIndex = 0, size_t endIndex = 0):startIndex(startIndex),
endIndex(endIndex) {} endIndex(endIndex) {}
int32_t getSize() const { size_t getSize() const {
return endIndex-startIndex; return endIndex-startIndex;
} }
int32_t getMidIndex() const { size_t getMidIndex() const {
return (endIndex-startIndex)/2+startIndex; return (endIndex-startIndex)/2+startIndex;
} }
@ -339,59 +340,63 @@ public:
} }
}; };
int32_t BitfieldMan::getStartIndex(int32_t index) const { size_t BitfieldMan::getStartIndex(size_t index) const {
while(index < blocks && (isUseBitSet(index) || isBitSet(index))) { while(index < blocks && (isUseBitSet(index) || isBitSet(index))) {
index++; index++;
} }
if((int32_t)blocks <= index) { if(blocks <= index) {
return -1; return blocks;
} else { } else {
return index; return index;
} }
} }
int32_t BitfieldMan::getEndIndex(int32_t index) const { size_t BitfieldMan::getEndIndex(size_t index) const {
while(index < blocks && (!isUseBitSet(index) && !isBitSet(index))) { while(index < blocks && (!isUseBitSet(index) && !isBitSet(index))) {
index++; index++;
} }
return index; return index;
} }
int32_t BitfieldMan::getSparseMissingUnusedIndex() const { bool BitfieldMan::getSparseMissingUnusedIndex(size_t& index) const {
Range maxRange; Range maxRange;
int32_t index = 0;
Range currentRange; Range currentRange;
while(index < blocks) { {
currentRange.startIndex = getStartIndex(index); size_t nextIndex = 0;
if(currentRange.startIndex == -1) { while(nextIndex < blocks) {
break; currentRange.startIndex = getStartIndex(nextIndex);
if(currentRange.startIndex == blocks) {
break;
}
currentRange.endIndex = getEndIndex(currentRange.startIndex);
if(maxRange < currentRange) {
maxRange = currentRange;
}
nextIndex = currentRange.endIndex;
} }
currentRange.endIndex = getEndIndex(currentRange.startIndex);
if(maxRange < currentRange) {
maxRange = currentRange;
}
index = currentRange.endIndex;
} }
if(maxRange.getSize()) { if(maxRange.getSize()) {
if(maxRange.startIndex == 0) { if(maxRange.startIndex == 0) {
return 0; index = 0;
} else if(isUseBitSet(maxRange.startIndex-1)) { } else if(isUseBitSet(maxRange.startIndex-1)) {
return maxRange.getMidIndex(); index = maxRange.getMidIndex();
} else { } else {
return maxRange.startIndex; index = maxRange.startIndex;
} }
return true;
} else { } else {
return -1; return false;
} }
} }
template<typename Array> template<typename Array>
std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const std::deque<size_t>
BitfieldMan::getAllMissingIndexes(const Array& bitfield, size_t bitfieldLength) const
{ {
std::deque<int32_t> missingIndexes; std::deque<size_t> missingIndexes;
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
int32_t base = i*8; size_t base = i*8;
for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) { for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
unsigned char mask = 128 >> bi; unsigned char mask = 128 >> bi;
if(bitfield[i] & mask) { if(bitfield[i] & mask) {
missingIndexes.push_back(base+bi); missingIndexes.push_back(base+bi);
@ -401,7 +406,7 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int
return missingIndexes; return missingIndexes;
} }
std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const { std::deque<size_t> BitfieldMan::getAllMissingIndexes() const {
array_fun<unsigned char> bf = array_negate(bitfield); array_fun<unsigned char> bf = array_negate(bitfield);
if(filterEnabled) { if(filterEnabled) {
bf = array_and(bf, filterBitfield); bf = array_and(bf, filterBitfield);
@ -409,9 +414,9 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
return getAllMissingIndexes(bf, bitfieldLength); return getAllMissingIndexes(bf, bitfieldLength);
} }
std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, int32_t peerBitfieldLength) const { std::deque<size_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, size_t peerBitfieldLength) const {
if(bitfieldLength != peerBitfieldLength) { if(bitfieldLength != peerBitfieldLength) {
return std::deque<int32_t>(); return std::deque<size_t>();
} }
array_fun<unsigned char> bf = array_and(array_negate(bitfield), array_fun<unsigned char> bf = array_and(array_negate(bitfield),
peerBitfield); peerBitfield);
@ -421,17 +426,17 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerB
return getAllMissingIndexes(bf, bitfieldLength); return getAllMissingIndexes(bf, bitfieldLength);
} }
int32_t BitfieldMan::countMissingBlock() const { size_t BitfieldMan::countMissingBlock() const {
return cachedNumMissingBlock; return cachedNumMissingBlock;
} }
int32_t BitfieldMan::countMissingBlockNow() const { size_t BitfieldMan::countMissingBlockNow() const {
if(filterEnabled) { if(filterEnabled) {
unsigned char* temp = new unsigned char[bitfieldLength]; unsigned char* temp = new unsigned char[bitfieldLength];
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
temp[i] = bitfield[i]&filterBitfield[i]; temp[i] = bitfield[i]&filterBitfield[i];
} }
int32_t count = countSetBit(filterBitfield, bitfieldLength)- size_t count = countSetBit(filterBitfield, bitfieldLength)-
countSetBit(temp, bitfieldLength); countSetBit(temp, bitfieldLength);
delete [] temp; delete [] temp;
return count; return count;
@ -440,15 +445,15 @@ int32_t BitfieldMan::countMissingBlockNow() const {
} }
} }
int32_t BitfieldMan::countFilteredBlock() const { size_t BitfieldMan::countFilteredBlock() const {
return cachedNumFilteredBlock; return cachedNumFilteredBlock;
} }
int32_t BitfieldMan::countBlock() const { size_t BitfieldMan::countBlock() const {
return blocks; return blocks;
} }
int32_t BitfieldMan::countFilteredBlockNow() const { size_t BitfieldMan::countFilteredBlockNow() const {
if(filterEnabled) { if(filterEnabled) {
return countSetBit(filterBitfield, bitfieldLength); return countSetBit(filterBitfield, bitfieldLength);
} else { } else {
@ -456,12 +461,12 @@ int32_t BitfieldMan::countFilteredBlockNow() const {
} }
} }
int32_t BitfieldMan::getMaxIndex() const size_t BitfieldMan::getMaxIndex() const
{ {
return blocks-1; return blocks-1;
} }
bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on) { bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) {
if(blocks <= index) { return false; } if(blocks <= index) { return false; }
unsigned char mask = 128 >> index%8; unsigned char mask = 128 >> index%8;
if(on) { if(on) {
@ -472,21 +477,21 @@ bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on
return true; return true;
} }
bool BitfieldMan::setUseBit(int32_t index) { bool BitfieldMan::setUseBit(size_t index) {
return setBitInternal(useBitfield, index, true); return setBitInternal(useBitfield, index, true);
} }
bool BitfieldMan::unsetUseBit(int32_t index) { bool BitfieldMan::unsetUseBit(size_t index) {
return setBitInternal(useBitfield, index, false); return setBitInternal(useBitfield, index, false);
} }
bool BitfieldMan::setBit(int32_t index) { bool BitfieldMan::setBit(size_t index) {
bool b = setBitInternal(bitfield, index, true); bool b = setBitInternal(bitfield, index, true);
updateCache(); updateCache();
return b; return b;
} }
bool BitfieldMan::unsetBit(int32_t index) { bool BitfieldMan::unsetBit(size_t index) {
bool b = setBitInternal(bitfield, index, false); bool b = setBitInternal(bitfield, index, false);
updateCache(); updateCache();
return b; return b;
@ -494,7 +499,7 @@ bool BitfieldMan::unsetBit(int32_t index) {
bool BitfieldMan::isFilteredAllBitSet() const { bool BitfieldMan::isFilteredAllBitSet() const {
if(filterEnabled) { if(filterEnabled) {
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
if((bitfield[i]&filterBitfield[i]) != filterBitfield[i]) { if((bitfield[i]&filterBitfield[i]) != filterBitfield[i]) {
return false; return false;
} }
@ -509,7 +514,7 @@ bool BitfieldMan::isAllBitSet() const {
if(bitfieldLength == 0) { if(bitfieldLength == 0) {
return true; return true;
} }
for(int32_t i = 0; i < bitfieldLength-1; ++i) { for(size_t i = 0; i < bitfieldLength-1; ++i) {
if(bitfield[i] != 0xff) { if(bitfield[i] != 0xff) {
return false; return false;
} }
@ -521,21 +526,21 @@ bool BitfieldMan::isAllBitSet() const {
return true; return true;
} }
bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, int32_t index) const { bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, size_t index) const {
if(index < 0 || blocks <= index) { return false; } if(index < 0 || blocks <= index) { return false; }
unsigned char mask = 128 >> index%8; unsigned char mask = 128 >> index%8;
return (bitfield[index/8] & mask) != 0; return (bitfield[index/8] & mask) != 0;
} }
bool BitfieldMan::isBitSet(int32_t index) const { bool BitfieldMan::isBitSet(size_t index) const {
return isBitSetInternal(bitfield, index); return isBitSetInternal(bitfield, index);
} }
bool BitfieldMan::isUseBitSet(int32_t index) const { bool BitfieldMan::isUseBitSet(size_t index) const {
return isBitSetInternal(useBitfield, index); return isBitSetInternal(useBitfield, index);
} }
void BitfieldMan::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) { void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) {
if(this->bitfieldLength != bitfieldLength) { if(this->bitfieldLength != bitfieldLength) {
return; return;
} }
@ -549,7 +554,7 @@ const unsigned char* BitfieldMan::getBitfield() const
return bitfield; return bitfield;
} }
int32_t BitfieldMan::getBitfieldLength() const size_t BitfieldMan::getBitfieldLength() const
{ {
return bitfieldLength; return bitfieldLength;
} }
@ -560,7 +565,7 @@ void BitfieldMan::clearAllBit() {
} }
void BitfieldMan::setAllBit() { void BitfieldMan::setAllBit() {
for(int32_t i = 0; i < blocks; ++i) { for(size_t i = 0; i < blocks; ++i) {
setBitInternal(bitfield, i, true); setBitInternal(bitfield, i, true);
} }
updateCache(); updateCache();
@ -572,23 +577,23 @@ void BitfieldMan::clearAllUseBit() {
} }
void BitfieldMan::setAllUseBit() { void BitfieldMan::setAllUseBit() {
for(int32_t i = 0; i < blocks; ++i) { for(size_t i = 0; i < blocks; ++i) {
setBitInternal(useBitfield, i, true); setBitInternal(useBitfield, i, true);
} }
} }
bool BitfieldMan::setFilterBit(int32_t index) { bool BitfieldMan::setFilterBit(size_t index) {
return setBitInternal(filterBitfield, index, true); return setBitInternal(filterBitfield, index, true);
} }
void BitfieldMan::addFilter(int64_t offset, int64_t length) { void BitfieldMan::addFilter(uint64_t offset, uint64_t length) {
if(!filterBitfield) { if(!filterBitfield) {
filterBitfield = new unsigned char[bitfieldLength]; filterBitfield = new unsigned char[bitfieldLength];
memset(filterBitfield, 0, bitfieldLength); memset(filterBitfield, 0, bitfieldLength);
} }
int32_t startBlock = offset/blockLength; size_t startBlock = offset/blockLength;
int32_t endBlock = (offset+length-1)/blockLength; size_t endBlock = (offset+length-1)/blockLength;
for(int i = startBlock; i <= endBlock && i < blocks; i++) { for(size_t i = startBlock; i <= endBlock && i < blocks; i++) {
setFilterBit(i); setFilterBit(i);
} }
updateCache(); updateCache();
@ -617,29 +622,29 @@ bool BitfieldMan::isFilterEnabled() const {
return filterEnabled; return filterEnabled;
} }
int64_t BitfieldMan::getFilteredTotalLength() const { uint64_t BitfieldMan::getFilteredTotalLength() const {
return cachedFilteredTotalLength; return cachedFilteredTotalLength;
} }
int64_t BitfieldMan::getFilteredTotalLengthNow() const { uint64_t BitfieldMan::getFilteredTotalLengthNow() const {
if(!filterBitfield) { if(!filterBitfield) {
return 0; return 0;
} }
int32_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength); size_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength);
if(filteredBlocks == 0) { if(filteredBlocks == 0) {
return 0; return 0;
} }
if(isBitSetInternal(filterBitfield, blocks-1)) { if(isBitSetInternal(filterBitfield, blocks-1)) {
return ((int64_t)filteredBlocks-1)*blockLength+getLastBlockLength(); return ((uint64_t)filteredBlocks-1)*blockLength+getLastBlockLength();
} else { } else {
return ((int64_t)filteredBlocks)*blockLength; return ((uint64_t)filteredBlocks)*blockLength;
} }
} }
int64_t BitfieldMan::getCompletedLength(bool useFilter) const { uint64_t BitfieldMan::getCompletedLength(bool useFilter) const {
unsigned char* temp = new unsigned char[bitfieldLength]; unsigned char* temp = new unsigned char[bitfieldLength];
if(useFilter) { if(useFilter) {
for(int32_t i = 0; i < bitfieldLength; ++i) { for(size_t i = 0; i < bitfieldLength; ++i) {
temp[i] = bitfield[i]; temp[i] = bitfield[i];
if(filterEnabled) { if(filterEnabled) {
temp[i] &= filterBitfield[i]; temp[i] &= filterBitfield[i];
@ -648,34 +653,34 @@ int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
} else { } else {
memcpy(temp, bitfield, bitfieldLength); memcpy(temp, bitfield, bitfieldLength);
} }
int32_t completedBlocks = countSetBit(temp, bitfieldLength); size_t completedBlocks = countSetBit(temp, bitfieldLength);
int64_t completedLength = 0; uint64_t completedLength = 0;
if(completedBlocks == 0) { if(completedBlocks == 0) {
completedLength = 0; completedLength = 0;
} else { } else {
if(isBitSetInternal(temp, blocks-1)) { if(isBitSetInternal(temp, blocks-1)) {
completedLength = ((int64_t)completedBlocks-1)*blockLength+getLastBlockLength(); completedLength = ((uint64_t)completedBlocks-1)*blockLength+getLastBlockLength();
} else { } else {
completedLength = ((int64_t)completedBlocks)*blockLength; completedLength = ((uint64_t)completedBlocks)*blockLength;
} }
} }
delete [] temp; delete [] temp;
return completedLength; return completedLength;
} }
int64_t BitfieldMan::getCompletedLength() const { uint64_t BitfieldMan::getCompletedLength() const {
return cachedCompletedLength; return cachedCompletedLength;
} }
int64_t BitfieldMan::getCompletedLengthNow() const { uint64_t BitfieldMan::getCompletedLengthNow() const {
return getCompletedLength(false); return getCompletedLength(false);
} }
int64_t BitfieldMan::getFilteredCompletedLength() const { uint64_t BitfieldMan::getFilteredCompletedLength() const {
return cachedFilteredComletedLength; return cachedFilteredComletedLength;
} }
int64_t BitfieldMan::getFilteredCompletedLengthNow() const { uint64_t BitfieldMan::getFilteredCompletedLengthNow() const {
return getCompletedLength(true); return getCompletedLength(true);
} }
@ -688,9 +693,9 @@ void BitfieldMan::updateCache()
cachedFilteredComletedLength = getFilteredCompletedLengthNow(); cachedFilteredComletedLength = getFilteredCompletedLengthNow();
} }
bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const bool BitfieldMan::isBitRangeSet(size_t startIndex, size_t endIndex) const
{ {
for(int32_t i = startIndex; i <= endIndex; ++i) { for(size_t i = startIndex; i <= endIndex; ++i) {
if(!isBitSet(i)) { if(!isBitSet(i)) {
return false; return false;
} }
@ -698,23 +703,23 @@ bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const
return true; return true;
} }
void BitfieldMan::unsetBitRange(int32_t startIndex, int32_t endIndex) void BitfieldMan::unsetBitRange(size_t startIndex, size_t endIndex)
{ {
for(int32_t i = startIndex; i <= endIndex; ++i) { for(size_t i = startIndex; i <= endIndex; ++i) {
unsetBit(i); unsetBit(i);
} }
updateCache(); updateCache();
} }
void BitfieldMan::setBitRange(int32_t startIndex, int32_t endIndex) void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex)
{ {
for(int32_t i = startIndex; i <= endIndex; ++i) { for(size_t i = startIndex; i <= endIndex; ++i) {
setBit(i); setBit(i);
} }
updateCache(); updateCache();
} }
bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const
{ {
if(length <= 0) { if(length <= 0) {
return false; return false;
@ -725,9 +730,9 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
if(totalLength < offset+length) { if(totalLength < offset+length) {
length = totalLength-offset; length = totalLength-offset;
} }
int32_t startBlock = offset/blockLength; size_t startBlock = offset/blockLength;
int32_t endBlock = (offset+length-1)/blockLength; size_t endBlock = (offset+length-1)/blockLength;
for(int32_t i = startBlock; i <= endBlock; i++) { for(size_t i = startBlock; i <= endBlock; i++) {
if(!isBitSet(i)) { if(!isBitSet(i)) {
return false; return false;
} }
@ -735,13 +740,13 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
return true; return true;
} }
int64_t BitfieldMan::getMissingUnusedLength(int32_t startingIndex) const uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
{ {
if(startingIndex < 0 || blocks <= startingIndex) { if(startingIndex < 0 || blocks <= startingIndex) {
return 0; return 0;
} }
int64_t length = 0; uint64_t length = 0;
for(int32_t i = startingIndex; i < blocks; ++i) { for(size_t i = startingIndex; i < blocks; ++i) {
if(isBitSet(i) || isUseBitSet(i)) { if(isBitSet(i) || isUseBitSet(i)) {
break; break;
} }

129
src/BitfieldMan.h
View File

@ -45,121 +45,120 @@ class Randomizer;
class BitfieldMan { class BitfieldMan {
private: private:
int32_t blockLength; size_t blockLength;
int64_t totalLength; uint64_t totalLength;
unsigned char* bitfield; unsigned char* bitfield;
unsigned char* useBitfield; unsigned char* useBitfield;
unsigned char* filterBitfield; unsigned char* filterBitfield;
int32_t bitfieldLength; size_t bitfieldLength;
int32_t blocks; size_t blocks;
bool filterEnabled; bool filterEnabled;
SharedHandle<Randomizer> randomizer; SharedHandle<Randomizer> randomizer;
// for caching // for caching
int32_t cachedNumMissingBlock; size_t cachedNumMissingBlock;
int32_t cachedNumFilteredBlock; size_t cachedNumFilteredBlock;
int64_t cachedCompletedLength; uint64_t cachedCompletedLength;
int64_t cachedFilteredComletedLength; uint64_t cachedFilteredComletedLength;
int64_t cachedFilteredTotalLength; uint64_t cachedFilteredTotalLength;
int32_t countSetBit(const unsigned char* bitfield, int32_t len) const; size_t countSetBit(const unsigned char* bitfield, size_t len) const;
int32_t getNthBitIndex(const unsigned char bit, int32_t nth) const; size_t getNthBitIndex(const unsigned char bit, size_t nth) const;
int32_t getMissingIndexRandomly(const unsigned char* bitfield, int32_t len) const; bool getMissingIndexRandomly(size_t& index, const unsigned char* bitfield, size_t len) const;
template<typename Array> template<typename Array>
int32_t bool getMissingIndexRandomly(size_t& index, const Array& bitfield,
getMissingIndexRandomly(const Array& bitfield, size_t bitfieldLength) const;
int32_t bitfieldLength) const;
template<typename Array> template<typename Array>
int32_t getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const; bool getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const;
template<typename Array> template<typename Array>
std::deque<int32_t> getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const; std::deque<size_t> getAllMissingIndexes(const Array& bitfield, size_t bitfieldLength) const;
bool isBitSetInternal(const unsigned char* bitfield, int32_t index) const; bool isBitSetInternal(const unsigned char* bitfield, size_t index) const;
bool setBitInternal(unsigned char* bitfield, int32_t index, bool on); bool setBitInternal(unsigned char* bitfield, size_t index, bool on);
bool setFilterBit(int32_t index); bool setFilterBit(size_t index);
int32_t getStartIndex(int32_t index) const; size_t getStartIndex(size_t index) const;
int32_t getEndIndex(int32_t index) const; size_t getEndIndex(size_t index) const;
int64_t getCompletedLength(bool useFilter) const; uint64_t getCompletedLength(bool useFilter) const;
public: public:
BitfieldMan(int32_t blockLength, int64_t totalLength); BitfieldMan(size_t blockLength, uint64_t totalLength);
BitfieldMan(const BitfieldMan& bitfieldMan); BitfieldMan(const BitfieldMan& bitfieldMan);
~BitfieldMan(); ~BitfieldMan();
BitfieldMan& operator=(const BitfieldMan& bitfieldMan); BitfieldMan& operator=(const BitfieldMan& bitfieldMan);
int32_t getBlockLength() const; size_t getBlockLength() const;
int32_t getLastBlockLength() const; size_t getLastBlockLength() const;
int32_t getBlockLength(int32_t index) const; size_t getBlockLength(size_t index) const;
int64_t getTotalLength() const { return totalLength; } uint64_t getTotalLength() const { return totalLength; }
/** /**
* affected by filter * affected by filter
*/ */
bool hasMissingPiece(const unsigned char* bitfield, int32_t len) const; bool hasMissingPiece(const unsigned char* bitfield, size_t len) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getMissingIndex(const unsigned char* bitfield, int32_t len) const; bool getMissingIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getMissingIndex() const; bool getMissingIndex(size_t& index) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getFirstMissingUnusedIndex(const unsigned char* bitfield, int32_t len) const; bool getFirstMissingUnusedIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getFirstMissingUnusedIndex() const; bool getFirstMissingUnusedIndex(size_t& index) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getFirstMissingIndex() const; bool getFirstMissingIndex(size_t& index) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getMissingUnusedIndex(const unsigned char* bitfield, int32_t len) const; bool getMissingUnusedIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getMissingUnusedIndex() const; bool getMissingUnusedIndex(size_t& index) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t getSparseMissingUnusedIndex() const; bool getSparseMissingUnusedIndex(size_t& index) const;
/** /**
* affected by filter * affected by filter
*/ */
std::deque<int32_t> getAllMissingIndexes() const; std::deque<size_t> getAllMissingIndexes() const;
/** /**
* affected by filter * affected by filter
*/ */
std::deque<int32_t> getAllMissingIndexes(const unsigned char* bitfield, int32_t len) const; std::deque<size_t> getAllMissingIndexes(const unsigned char* bitfield, size_t len) const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t countMissingBlock() const; size_t countMissingBlock() const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t countMissingBlockNow() const; size_t countMissingBlockNow() const;
bool setUseBit(int32_t index); bool setUseBit(size_t index);
bool unsetUseBit(int32_t index); bool unsetUseBit(size_t index);
bool setBit(int32_t index); bool setBit(size_t index);
bool unsetBit(int32_t index); bool unsetBit(size_t index);
bool isBitSet(int32_t index) const; bool isBitSet(size_t index) const;
bool isUseBitSet(int32_t index) const; bool isUseBitSet(size_t index) const;
/** /**
* affected by filter * affected by filter
@ -170,22 +169,22 @@ public:
const unsigned char* getBitfield() const; const unsigned char* getBitfield() const;
int32_t getBitfieldLength() const; size_t getBitfieldLength() const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t countFilteredBlock() const; size_t countFilteredBlock() const;
int32_t countBlock() const; size_t countBlock() const;
/** /**
* affected by filter * affected by filter
*/ */
int32_t countFilteredBlockNow() const; size_t countFilteredBlockNow() const;
int32_t getMaxIndex() const; size_t getMaxIndex() const;
void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength); void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
void clearAllBit(); void clearAllBit();
void setAllBit(); void setAllBit();
@ -193,7 +192,7 @@ public:
void clearAllUseBit(); void clearAllUseBit();
void setAllUseBit(); void setAllUseBit();
void addFilter(int64_t offset, int64_t length); void addFilter(uint64_t offset, uint64_t length);
/** /**
* Clears filter and disables filter * Clears filter and disables filter
*/ */
@ -205,24 +204,24 @@ public:
/** /**
* affected by filter * affected by filter
*/ */
int64_t getFilteredTotalLength() const; uint64_t getFilteredTotalLength() const;
/** /**
* affected by filter * affected by filter
*/ */
int64_t getFilteredTotalLengthNow() const; uint64_t getFilteredTotalLengthNow() const;
int64_t getCompletedLength() const; uint64_t getCompletedLength() const;
int64_t getCompletedLengthNow() const; uint64_t getCompletedLengthNow() const;
/** /**
* affected by filter * affected by filter
*/ */
int64_t getFilteredCompletedLength() const; uint64_t getFilteredCompletedLength() const;
/** /**
* affected by filter * affected by filter
*/ */
int64_t getFilteredCompletedLengthNow() const; uint64_t getFilteredCompletedLengthNow() const;
void setRandomizer(const SharedHandle<Randomizer>& randomizer); void setRandomizer(const SharedHandle<Randomizer>& randomizer);
@ -230,15 +229,15 @@ public:
void updateCache(); void updateCache();
bool isBitRangeSet(int32_t startIndex, int32_t endIndex) const; bool isBitRangeSet(size_t startIndex, size_t endIndex) const;
void unsetBitRange(int32_t startIndex, int32_t endIndex); void unsetBitRange(size_t startIndex, size_t endIndex);
void setBitRange(int32_t startIndex, int32_t endIndex); void setBitRange(size_t startIndex, size_t endIndex);
bool isBitSetOffsetRange(int64_t offset, int64_t length) const; bool isBitSetOffsetRange(uint64_t offset, uint64_t length) const;
int64_t getMissingUnusedLength(int32_t startingIndex) const; uint64_t getMissingUnusedLength(size_t startingIndex) const;
}; };

4
src/BtRequestFactory.h
View File

@ -66,14 +66,14 @@ public:
* The number of objects returned is capped by max. * The number of objects returned is capped by max.
*/ */
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessages(int32_t max) = 0; createRequestMessages(size_t max) = 0;
/** /**
* Use this method in end game mode. * Use this method in end game mode.
* *
*/ */
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessagesOnEndGame(int32_t max) = 0; createRequestMessagesOnEndGame(size_t max) = 0;
}; };
typedef SharedHandle<BtRequestFactory> BtRequestFactoryHandle; typedef SharedHandle<BtRequestFactory> BtRequestFactoryHandle;

4
src/DefaultBtInteractive.cc
View File

@ -199,7 +199,7 @@ void DefaultBtInteractive::decideChoking() {
} }
void DefaultBtInteractive::checkHave() { void DefaultBtInteractive::checkHave() {
std::deque<int32_t> indexes = std::deque<size_t> indexes =
pieceStorage->getAdvertisedPieceIndexes(cuid, haveCheckPoint); pieceStorage->getAdvertisedPieceIndexes(cuid, haveCheckPoint);
haveCheckPoint.reset(); haveCheckPoint.reset();
if(indexes.size() >= 20) { if(indexes.size() >= 20) {
@ -209,7 +209,7 @@ void DefaultBtInteractive::checkHave() {
dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage()); dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
} }
} else { } else {
for(std::deque<int32_t>::iterator itr = indexes.begin(); itr != indexes.end(); itr++) { for(std::deque<size_t>::iterator itr = indexes.begin(); itr != indexes.end(); itr++) {
dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr)); dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
} }
} }

20
src/DefaultBtProgressInfoFile.cc
View File

@ -233,26 +233,26 @@ void DefaultBtProgressInfoFile::load()
delete [] savedBitfield; delete [] savedBitfield;
savedBitfield = 0; savedBitfield = 0;
int32_t numInFlightPiece; uint32_t numInFlightPiece;
in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece)); in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece));
Pieces inFlightPieces; Pieces inFlightPieces;
while(numInFlightPiece--) { while(numInFlightPiece--) {
int32_t index; uint32_t index;
in.read(reinterpret_cast<char*>(&index), sizeof(index)); in.read(reinterpret_cast<char*>(&index), sizeof(index));
if(!(0 <= index && index < _dctx->getNumPieces())) { if(!(index < _dctx->getNumPieces())) {
throw new DlAbortEx("piece index out of range: %d", index); throw new DlAbortEx("piece index out of range: %u", index);
} }
int32_t length; uint32_t length;
in.read(reinterpret_cast<char*>(&length), sizeof(length)); in.read(reinterpret_cast<char*>(&length), sizeof(length));
if(!(0 < length && length <=_dctx->getPieceLength())) { if(!(length <=_dctx->getPieceLength())) {
throw new DlAbortEx("piece length out of range: %d", length); throw new DlAbortEx("piece length out of range: %u", length);
} }
PieceHandle piece = new Piece(index, length); PieceHandle piece = new Piece(index, length);
int32_t bitfieldLength; uint32_t bitfieldLength;
in.read(reinterpret_cast<char*>(&bitfieldLength), sizeof(bitfieldLength)); in.read(reinterpret_cast<char*>(&bitfieldLength), sizeof(bitfieldLength));
if(piece->getBitfieldLength() != bitfieldLength) { if(piece->getBitfieldLength() != bitfieldLength) {
throw new DlAbortEx("piece bitfield length mismatch. expected: %d actual: %d", throw new DlAbortEx("piece bitfield length mismatch. expected: %u actual: %u",
piece->getBitfieldLength(), bitfieldLength); piece->getBitfieldLength(), bitfieldLength);
} }
savedBitfield = new unsigned char[bitfieldLength]; savedBitfield = new unsigned char[bitfieldLength];
@ -265,7 +265,7 @@ void DefaultBtProgressInfoFile::load()
} }
_pieceStorage->addInFlightPiece(inFlightPieces); _pieceStorage->addInFlightPiece(inFlightPieces);
} else { } else {
int32_t numInFlightPiece; uint32_t numInFlightPiece;
in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece)); in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece));
BitfieldMan src(pieceLength, totalLength); BitfieldMan src(pieceLength, totalLength);
src.setBitfield(savedBitfield, bitfieldLength); src.setBitfield(savedBitfield, bitfieldLength);

25
src/DefaultBtRequestFactory.cc
View File

@ -109,31 +109,32 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
pieces.clear(); pieces.clear();
} }
BtMessages DefaultBtRequestFactory::createRequestMessages(int32_t max) { BtMessages DefaultBtRequestFactory::createRequestMessages(size_t max)
{
BtMessages requests; BtMessages requests;
for(Pieces::iterator itr = pieces.begin(); for(Pieces::iterator itr = pieces.begin();
itr != pieces.end() && requests.size() < (size_t)max; itr++) { itr != pieces.end() && requests.size() < max; itr++) {
PieceHandle& piece = *itr; PieceHandle& piece = *itr;
int32_t blockIndex; size_t blockIndex;
while(requests.size() < (size_t)max && while(requests.size() < max &&
(blockIndex = piece->getMissingUnusedBlockIndex()) != -1) { piece->getMissingUnusedBlockIndex(blockIndex)) {
requests.push_back(messageFactory->createRequestMessage(piece, blockIndex)); requests.push_back(messageFactory->createRequestMessage(piece, blockIndex));
} }
} }
return requests; return requests;
} }
BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(int32_t max) { BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(size_t max)
{
BtMessages requests; BtMessages requests;
for(Pieces::iterator itr = pieces.begin(); for(Pieces::iterator itr = pieces.begin();
itr != pieces.end() && requests.size() < (size_t)max; itr++) { itr != pieces.end() && requests.size() < max; itr++) {
PieceHandle& piece = *itr; PieceHandle& piece = *itr;
std::deque<int32_t> missingBlockIndexes = piece->getAllMissingBlockIndexes(); std::deque<size_t> missingBlockIndexes = piece->getAllMissingBlockIndexes();
random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end()); random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end());
for(std::deque<int32_t>::const_iterator bitr = missingBlockIndexes.begin(); for(std::deque<size_t>::const_iterator bitr = missingBlockIndexes.begin();
bitr != missingBlockIndexes.end() && requests.size() < (size_t)max; bitr != missingBlockIndexes.end() && requests.size() < max; bitr++) {
bitr++) { size_t blockIndex = *bitr;
int32_t blockIndex = *bitr;
if(!dispatcher->isOutstandingRequest(piece->getIndex(), if(!dispatcher->isOutstandingRequest(piece->getIndex(),
blockIndex)) { blockIndex)) {
requests.push_back(messageFactory->createRequestMessage(piece, blockIndex)); requests.push_back(messageFactory->createRequestMessage(piece, blockIndex));

4
src/DefaultBtRequestFactory.h
View File

@ -75,10 +75,10 @@ public:
virtual void doChokedAction(); virtual void doChokedAction();
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessages(int32_t max); createRequestMessages(size_t max);
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessagesOnEndGame(int32_t max); createRequestMessagesOnEndGame(size_t max);
std::deque<SharedHandle<Piece> >& getTargetPieces(); std::deque<SharedHandle<Piece> >& getTargetPieces();

130
src/DefaultPieceStorage.cc
View File

@ -86,24 +86,19 @@ bool DefaultPieceStorage::isEndGame()
return bitfieldMan->countMissingBlock() <= endGamePieceNum; return bitfieldMan->countMissingBlock() <= endGamePieceNum;
} }
int32_t DefaultPieceStorage::getMissingPieceIndex(const PeerHandle& peer) bool DefaultPieceStorage::getMissingPieceIndex(size_t& index, const PeerHandle& peer)
{ {
int32_t index = -1;
if(isEndGame()) { if(isEndGame()) {
index = bitfieldMan->getMissingIndex(peer->getBitfield(), return bitfieldMan->getMissingIndex(index, peer->getBitfield(),
peer->getBitfieldLength()); peer->getBitfieldLength());
} else { } else {
index = bitfieldMan->getMissingUnusedIndex(peer->getBitfield(), return bitfieldMan->getMissingUnusedIndex(index, peer->getBitfield(),
peer->getBitfieldLength()); peer->getBitfieldLength());
} }
return index;
} }
PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index) PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
{ {
if(index == -1) {
return 0;
}
bitfieldMan->setUseBit(index); bitfieldMan->setUseBit(index);
PieceHandle piece = findUsedPiece(index); PieceHandle piece = findUsedPiece(index);
@ -120,7 +115,7 @@ PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index)
* Newly instantiated piece is not added to usedPieces. * Newly instantiated piece is not added to usedPieces.
* Because it is waste of memory and there is no chance to use them later. * Because it is waste of memory and there is no chance to use them later.
*/ */
PieceHandle DefaultPieceStorage::getPiece(int32_t index) PieceHandle DefaultPieceStorage::getPiece(size_t index)
{ {
if(0 <= index && index <= bitfieldMan->getMaxIndex()) { if(0 <= index && index <= bitfieldMan->getMaxIndex()) {
PieceHandle piece = findUsedPiece(index); PieceHandle piece = findUsedPiece(index);
@ -143,16 +138,16 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
class FindPiece { class FindPiece {
private: private:
int32_t index; size_t index;
public: public:
FindPiece(int32_t index):index(index) {} FindPiece(size_t index):index(index) {}
bool operator()(const PieceHandle& piece) { bool operator()(const PieceHandle& piece) {
return piece->getIndex() == index; return piece->getIndex() == index;
} }
}; };
PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const PieceHandle DefaultPieceStorage::findUsedPiece(size_t index) const
{ {
Pieces::const_iterator itr = std::find_if(usedPieces.begin(), Pieces::const_iterator itr = std::find_if(usedPieces.begin(),
usedPieces.end(), usedPieces.end(),
@ -166,13 +161,17 @@ PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const
PieceHandle DefaultPieceStorage::getMissingPiece(const PeerHandle& peer) PieceHandle DefaultPieceStorage::getMissingPiece(const PeerHandle& peer)
{ {
int32_t index = getMissingPieceIndex(peer); size_t index;
return checkOutPiece(index); if(getMissingPieceIndex(index, peer)) {
return checkOutPiece(index);
} else {
return 0;
}
} }
int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer) bool DefaultPieceStorage::getMissingFastPieceIndex(size_t& index,
const PeerHandle& peer)
{ {
int32_t index = -1;
if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) { if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(), BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength()); bitfieldMan->getTotalLength());
@ -183,28 +182,38 @@ int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer)
} }
} }
if(isEndGame()) { if(isEndGame()) {
index = bitfieldMan->getMissingIndex(tempBitfield.getBitfield(), return bitfieldMan->getMissingIndex(index, tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength()); tempBitfield.getBitfieldLength());
} else { } else {
index = bitfieldMan->getMissingUnusedIndex(tempBitfield.getBitfield(), return bitfieldMan->getMissingUnusedIndex(index,
tempBitfield.getBitfieldLength()); tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength());
} }
} }
return index; return false;
} }
PieceHandle DefaultPieceStorage::getMissingFastPiece(const PeerHandle& peer) PieceHandle DefaultPieceStorage::getMissingFastPiece(const PeerHandle& peer)
{ {
int32_t index = getMissingFastPieceIndex(peer); size_t index;
return checkOutPiece(index); if(getMissingFastPieceIndex(index, peer)) {
return checkOutPiece(index);
} else {
return 0;
}
} }
PieceHandle DefaultPieceStorage::getMissingPiece() PieceHandle DefaultPieceStorage::getMissingPiece()
{ {
return checkOutPiece(bitfieldMan->getSparseMissingUnusedIndex()); size_t index;
if(bitfieldMan->getSparseMissingUnusedIndex(index)) {
return checkOutPiece(index);
} else {
return 0;
}
} }
PieceHandle DefaultPieceStorage::getMissingPiece(int32_t index) PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
{ {
if(hasPiece(index) || isPieceUsed(index)) { if(hasPiece(index) || isPieceUsed(index)) {
return 0; return 0;
@ -224,15 +233,15 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
} }
} }
void DefaultPieceStorage::reduceUsedPieces(int32_t delMax) void DefaultPieceStorage::reduceUsedPieces(size_t delMax)
{ {
int32_t toDelete = usedPieces.size()-delMax; if(usedPieces.size() <= delMax) {
if(toDelete <= 0) {
return; return;
} }
int32_t fillRate = 10; size_t toDelete = usedPieces.size()-delMax;
int fillRate = 10;
while(fillRate < 50) { while(fillRate < 50) {
int32_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete); size_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete);
if(deleted == 0) { if(deleted == 0) {
break; break;
} }
@ -241,10 +250,10 @@ void DefaultPieceStorage::reduceUsedPieces(int32_t delMax)
} }
} }
int32_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int32_t fillRate, size_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int fillRate,
int32_t toDelete) size_t toDelete)
{ {
int32_t deleted = 0; size_t deleted = 0;
for(Pieces::iterator itr = usedPieces.begin(); for(Pieces::iterator itr = usedPieces.begin();
itr != usedPieces.end() && deleted < toDelete;) { itr != usedPieces.end() && deleted < toDelete;) {
PieceHandle& piece = *itr; PieceHandle& piece = *itr;
@ -315,39 +324,39 @@ void DefaultPieceStorage::cancelPiece(const PieceHandle& piece)
} }
} }
bool DefaultPieceStorage::hasPiece(int32_t index) bool DefaultPieceStorage::hasPiece(size_t index)
{ {
return bitfieldMan->isBitSet(index); return bitfieldMan->isBitSet(index);
} }
bool DefaultPieceStorage::isPieceUsed(int32_t index) bool DefaultPieceStorage::isPieceUsed(size_t index)
{ {
return bitfieldMan->isUseBitSet(index); return bitfieldMan->isUseBitSet(index);
} }
int64_t DefaultPieceStorage::getTotalLength() uint64_t DefaultPieceStorage::getTotalLength()
{ {
return bitfieldMan->getTotalLength(); return bitfieldMan->getTotalLength();
} }
int64_t DefaultPieceStorage::getFilteredTotalLength() uint64_t DefaultPieceStorage::getFilteredTotalLength()
{ {
return bitfieldMan->getFilteredTotalLength(); return bitfieldMan->getFilteredTotalLength();
} }
int64_t DefaultPieceStorage::getCompletedLength() uint64_t DefaultPieceStorage::getCompletedLength()
{ {
return bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength(); return bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength();
} }
int64_t DefaultPieceStorage::getFilteredCompletedLength() uint64_t DefaultPieceStorage::getFilteredCompletedLength()
{ {
return bitfieldMan->getFilteredCompletedLength()+getInFlightPieceCompletedLength(); return bitfieldMan->getFilteredCompletedLength()+getInFlightPieceCompletedLength();
} }
int32_t DefaultPieceStorage::getInFlightPieceCompletedLength() const size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const
{ {
return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<int32_t>(), mem_fun_sh(&Piece::getCompletedLength))); return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<size_t>(), mem_fun_sh(&Piece::getCompletedLength)));
} }
// not unittested // not unittested
@ -444,12 +453,12 @@ void DefaultPieceStorage::initStorage()
} }
void DefaultPieceStorage::setBitfield(const unsigned char* bitfield, void DefaultPieceStorage::setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength) size_t bitfieldLength)
{ {
bitfieldMan->setBitfield(bitfield, bitfieldLength); bitfieldMan->setBitfield(bitfield, bitfieldLength);
} }
int32_t DefaultPieceStorage::getBitfieldLength() size_t DefaultPieceStorage::getBitfieldLength()
{ {
return bitfieldMan->getBitfieldLength(); return bitfieldMan->getBitfieldLength();
} }
@ -463,21 +472,22 @@ DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() {
return diskAdaptor; return diskAdaptor;
} }
int32_t DefaultPieceStorage::getPieceLength(int32_t index) size_t DefaultPieceStorage::getPieceLength(size_t index)
{ {
return bitfieldMan->getBlockLength(index); return bitfieldMan->getBlockLength(index);
} }
void DefaultPieceStorage::advertisePiece(int32_t cuid, int32_t index) void DefaultPieceStorage::advertisePiece(int32_t cuid, size_t index)
{ {
HaveEntry entry(cuid, index); HaveEntry entry(cuid, index);
haves.push_front(entry); haves.push_front(entry);
} }
std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid, std::deque<size_t>
const Time& lastCheckTime) DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
const Time& lastCheckTime)
{ {
std::deque<int32_t> indexes; std::deque<size_t> indexes;
for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) { for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
const Haves::value_type& have = *itr; const Haves::value_type& have = *itr;
if(have.getCuid() == myCuid) { if(have.getCuid() == myCuid) {
@ -494,9 +504,9 @@ std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCui
class FindElapsedHave class FindElapsedHave
{ {
private: private:
int32_t elapsed; time_t elapsed;
public: public:
FindElapsedHave(int32_t elapsed):elapsed(elapsed) {} FindElapsedHave(time_t elapsed):elapsed(elapsed) {}
bool operator()(const HaveEntry& have) { bool operator()(const HaveEntry& have) {
if(have.getRegisteredTime().elapsed(elapsed)) { if(have.getRegisteredTime().elapsed(elapsed)) {
@ -507,7 +517,7 @@ public:
} }
}; };
void DefaultPieceStorage::removeAdvertisedPiece(int32_t elapsed) void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
{ {
Haves::iterator itr = Haves::iterator itr =
std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed)); std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
@ -522,19 +532,19 @@ void DefaultPieceStorage::markAllPiecesDone()
bitfieldMan->setAllBit(); bitfieldMan->setAllBit();
} }
void DefaultPieceStorage::markPiecesDone(int64_t length) void DefaultPieceStorage::markPiecesDone(uint64_t length)
{ {
if(length == bitfieldMan->getTotalLength()) { if(length == bitfieldMan->getTotalLength()) {
bitfieldMan->setAllBit(); bitfieldMan->setAllBit();
} else { } else {
int32_t numPiece = length/bitfieldMan->getBlockLength(); size_t numPiece = length/bitfieldMan->getBlockLength();
if(numPiece > 0) { if(numPiece > 0) {
bitfieldMan->setBitRange(0, numPiece-1); bitfieldMan->setBitRange(0, numPiece-1);
} }
int32_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH; size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
if(r > 0) { if(r > 0) {
PieceHandle p = new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)); PieceHandle p = new Piece(numPiece, bitfieldMan->getBlockLength(numPiece));
for(int32_t i = 0; i < r; ++i) { for(size_t i = 0; i < r; ++i) {
p->completeBlock(i); p->completeBlock(i);
} }
addUsedPiece(p); addUsedPiece(p);
@ -542,7 +552,7 @@ void DefaultPieceStorage::markPiecesDone(int64_t length)
} }
} }
void DefaultPieceStorage::markPieceMissing(int32_t index) void DefaultPieceStorage::markPieceMissing(size_t index)
{ {
bitfieldMan->unsetBit(index); bitfieldMan->unsetBit(index);
} }
@ -552,7 +562,7 @@ void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
std::copy(pieces.begin(), pieces.end(), std::back_inserter(usedPieces)); std::copy(pieces.begin(), pieces.end(), std::back_inserter(usedPieces));
} }
int32_t DefaultPieceStorage::countInFlightPiece() size_t DefaultPieceStorage::countInFlightPiece()
{ {
return usedPieces.size(); return usedPieces.size();
} }

60
src/DefaultPieceStorage.h
View File

@ -51,10 +51,10 @@ class FileEntry;
class HaveEntry { class HaveEntry {
private: private:
int32_t cuid; int32_t cuid;
int32_t index; size_t index;
Time registeredTime; Time registeredTime;
public: public:
HaveEntry(int32_t cuid, int32_t index): HaveEntry(int32_t cuid, size_t index):
cuid(cuid), cuid(cuid),
index(index) {} index(index) {}
@ -74,20 +74,20 @@ private:
SharedHandle<DiskAdaptor> diskAdaptor; SharedHandle<DiskAdaptor> diskAdaptor;
SharedHandle<DiskWriterFactory> _diskWriterFactory; SharedHandle<DiskWriterFactory> _diskWriterFactory;
std::deque<SharedHandle<Piece> > usedPieces; std::deque<SharedHandle<Piece> > usedPieces;
int32_t endGamePieceNum; size_t endGamePieceNum;
Logger* logger; Logger* logger;
const Option* option; const Option* option;
Haves haves; Haves haves;
int32_t getMissingPieceIndex(const SharedHandle<Peer>& peer); bool getMissingPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
int32_t getMissingFastPieceIndex(const SharedHandle<Peer>& peer); bool getMissingFastPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
SharedHandle<Piece> checkOutPiece(int32_t index); SharedHandle<Piece> checkOutPiece(size_t index);
int32_t deleteUsedPiecesByFillRate(int32_t fillRate, int32_t toDelete); size_t deleteUsedPiecesByFillRate(int fillRate, size_t toDelete);
void reduceUsedPieces(int32_t delMax); void reduceUsedPieces(size_t delMax);
void deleteUsedPiece(const SharedHandle<Piece>& piece); void deleteUsedPiece(const SharedHandle<Piece>& piece);
SharedHandle<Piece> findUsedPiece(int32_t index) const; SharedHandle<Piece> findUsedPiece(size_t index) const;
int32_t getInFlightPieceCompletedLength() const; size_t getInFlightPieceCompletedLength() const;
public: public:
DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option); DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option);
@ -101,25 +101,25 @@ public:
virtual SharedHandle<Piece> getMissingPiece(); virtual SharedHandle<Piece> getMissingPiece();
virtual SharedHandle<Piece> getMissingPiece(int32_t index); virtual SharedHandle<Piece> getMissingPiece(size_t index);
virtual SharedHandle<Piece> getPiece(int32_t index); virtual SharedHandle<Piece> getPiece(size_t index);
virtual void completePiece(const SharedHandle<Piece>& piece); virtual void completePiece(const SharedHandle<Piece>& piece);
virtual void cancelPiece(const SharedHandle<Piece>& piece); virtual void cancelPiece(const SharedHandle<Piece>& piece);
virtual bool hasPiece(int32_t index); virtual bool hasPiece(size_t index);
virtual bool isPieceUsed(int32_t index); virtual bool isPieceUsed(size_t index);
virtual int64_t getTotalLength(); virtual uint64_t getTotalLength();
virtual int64_t getFilteredTotalLength(); virtual uint64_t getFilteredTotalLength();
virtual int64_t getCompletedLength(); virtual uint64_t getCompletedLength();
virtual int64_t getFilteredCompletedLength(); virtual uint64_t getFilteredCompletedLength();
virtual void initStorage(); virtual void initStorage();
@ -134,17 +134,17 @@ public:
virtual bool allDownloadFinished(); virtual bool allDownloadFinished();
virtual void setBitfield(const unsigned char* bitfield, virtual void setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength); size_t bitfieldLength);
virtual int32_t getBitfieldLength(); virtual size_t getBitfieldLength();
virtual const unsigned char* getBitfield(); virtual const unsigned char* getBitfield();
void setEndGamePieceNum(int32_t num) { void setEndGamePieceNum(size_t num) {
endGamePieceNum = num; endGamePieceNum = num;
} }
int32_t getEndGamePieceNum() const { size_t getEndGamePieceNum() const {
return endGamePieceNum; return endGamePieceNum;
} }
@ -156,24 +156,24 @@ public:
virtual SharedHandle<DiskAdaptor> getDiskAdaptor(); virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
virtual int32_t getPieceLength(int32_t index); virtual size_t getPieceLength(size_t index);
virtual void advertisePiece(int32_t cuid, int32_t index); virtual void advertisePiece(int32_t cuid, size_t index);
virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid, virtual std::deque<size_t>
const Time& lastCheckTime); getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime);
virtual void removeAdvertisedPiece(int32_t elapsed); virtual void removeAdvertisedPiece(time_t elapsed);
virtual void markAllPiecesDone(); virtual void markAllPiecesDone();
virtual void markPiecesDone(int64_t length); virtual void markPiecesDone(uint64_t length);
virtual void markPieceMissing(int32_t index); virtual void markPieceMissing(size_t index);
virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces); virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
virtual int32_t countInFlightPiece(); virtual size_t countInFlightPiece();
virtual std::deque<SharedHandle<Piece> > getInFlightPieces(); virtual std::deque<SharedHandle<Piece> > getInFlightPieces();

2
src/DownloadCommand.cc
View File

@ -109,7 +109,7 @@ bool DownloadCommand::executeInternal() {
setReadCheckSocket(socket); setReadCheckSocket(socket);
SegmentHandle segment = _segments.front(); SegmentHandle segment = _segments.front();
int32_t BUFSIZE = 16*1024; size_t BUFSIZE = 16*1024;
unsigned char buf[BUFSIZE]; unsigned char buf[BUFSIZE];
int32_t bufSize; int32_t bufSize;
if(segment->getLength() > 0 && segment->getLength()-segment->getWrittenLength() < BUFSIZE) { if(segment->getLength() > 0 && segment->getLength()-segment->getWrittenLength() < BUFSIZE) {

2
src/GrowSegment.cc
View File

@ -42,7 +42,7 @@ GrowSegment::GrowSegment(const PieceHandle& piece):
GrowSegment::~GrowSegment() {} GrowSegment::~GrowSegment() {}
void GrowSegment::updateWrittenLength(int32_t bytes) void GrowSegment::updateWrittenLength(size_t bytes)
{ {
_writtenLength += bytes; _writtenLength += bytes;
_piece->reconfigure(_writtenLength); _piece->reconfigure(_writtenLength);

18
src/GrowSegment.h
View File

@ -42,7 +42,7 @@ namespace aria2 {
class GrowSegment:public Segment { class GrowSegment:public Segment {
private: private:
SharedHandle<Piece> _piece; SharedHandle<Piece> _piece;
int32_t _writtenLength; size_t _writtenLength;
public: public:
GrowSegment(const SharedHandle<Piece>& piece); GrowSegment(const SharedHandle<Piece>& piece);
@ -53,42 +53,42 @@ public:
return false; return false;
} }
virtual int32_t getIndex() const virtual size_t getIndex() const
{ {
return 0; return 0;
} }
virtual int64_t getPosition() const virtual off_t getPosition() const
{ {
return 0; return 0;
} }
virtual int64_t getPositionToWrite() const virtual off_t getPositionToWrite() const
{ {
return _writtenLength; return _writtenLength;
} }
virtual int32_t getLength() const virtual size_t getLength() const
{ {
return 0; return 0;
} }
virtual int32_t getSegmentLength() const virtual size_t getSegmentLength() const
{ {
return 0; return 0;
} }
virtual int32_t getWrittenLength() const virtual size_t getWrittenLength() const
{ {
return _writtenLength; return _writtenLength;
} }
virtual int32_t getOverflowLength() const virtual size_t getOverflowLength() const
{ {
return 0; return 0;
} }
virtual void updateWrittenLength(int32_t bytes); virtual void updateWrittenLength(size_t bytes);
virtual void clear(); virtual void clear();

70
src/Piece.cc
View File

@ -41,7 +41,7 @@ namespace aria2 {
Piece::Piece():index(0), length(0), _blockLength(BLOCK_LENGTH), bitfield(0) {} Piece::Piece():index(0), length(0), _blockLength(BLOCK_LENGTH), bitfield(0) {}
Piece::Piece(int32_t index, int32_t length, int32_t blockLength):index(index), length(length), _blockLength(blockLength) { Piece::Piece(size_t index, size_t length, size_t blockLength):index(index), length(length), _blockLength(blockLength) {
bitfield = bitfield =
BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length); BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
} }
@ -82,7 +82,7 @@ bool Piece::operator==(const Piece& piece) const
return index == piece.index; return index == piece.index;
} }
void Piece::completeBlock(int32_t blockIndex) { void Piece::completeBlock(size_t blockIndex) {
bitfield->setBit(blockIndex); bitfield->setBit(blockIndex);
bitfield->unsetUseBit(blockIndex); bitfield->unsetUseBit(blockIndex);
} }
@ -100,17 +100,17 @@ bool Piece::pieceComplete() const {
return bitfield->isAllBitSet(); return bitfield->isAllBitSet();
} }
int32_t Piece::countBlock() const size_t Piece::countBlock() const
{ {
return bitfield->countBlock(); return bitfield->countBlock();
} }
int32_t Piece::getBlockLength(int32_t index) const size_t Piece::getBlockLength(size_t index) const
{ {
return bitfield->getBlockLength(index); return bitfield->getBlockLength(index);
} }
int32_t Piece::getBlockLength() const size_t Piece::getBlockLength() const
{ {
return bitfield->getBlockLength(); return bitfield->getBlockLength();
} }
@ -120,54 +120,56 @@ const unsigned char* Piece::getBitfield() const
return bitfield->getBitfield(); return bitfield->getBitfield();
} }
int32_t Piece::getBitfieldLength() const size_t Piece::getBitfieldLength() const
{ {
return bitfield->getBitfieldLength(); return bitfield->getBitfieldLength();
} }
bool Piece::isBlockUsed(int32_t index) const bool Piece::isBlockUsed(size_t index) const
{ {
return bitfield->isUseBitSet(index); return bitfield->isUseBitSet(index);
} }
void Piece::cancelBlock(int32_t blockIndex) { void Piece::cancelBlock(size_t blockIndex) {
bitfield->unsetUseBit(blockIndex); bitfield->unsetUseBit(blockIndex);
} }
int32_t Piece::countCompleteBlock() const size_t Piece::countCompleteBlock() const
{ {
return bitfield->countBlock()-bitfield->countMissingBlock(); return bitfield->countBlock()-bitfield->countMissingBlock();
} }
bool Piece::hasBlock(int32_t blockIndex) const bool Piece::hasBlock(size_t blockIndex) const
{ {
return bitfield->isBitSet(blockIndex); return bitfield->isBitSet(blockIndex);
} }
int32_t Piece::getMissingUnusedBlockIndex() const { bool Piece::getMissingUnusedBlockIndex(size_t& index) const
int32_t blockIndex = bitfield->getFirstMissingUnusedIndex();
if(blockIndex == -1) {
return blockIndex;
}
bitfield->setUseBit(blockIndex);
return blockIndex;
}
int32_t Piece::getMissingBlockIndex() const {
int32_t blockIndex = bitfield->getMissingIndex();
if(blockIndex == -1) {
return blockIndex;
}
bitfield->setUseBit(blockIndex);
return blockIndex;
}
int32_t Piece::getFirstMissingBlockIndexWithoutLock() const
{ {
return bitfield->getFirstMissingIndex(); if(bitfield->getFirstMissingUnusedIndex(index)) {
bitfield->setUseBit(index);
return true;
} else {
return false;
}
} }
std::deque<int32_t> Piece::getAllMissingBlockIndexes() const { bool Piece::getMissingBlockIndex(size_t& index) const
{
if(bitfield->getMissingIndex(index)) {
bitfield->setUseBit(index);
return true;
} else {
return false;
}
}
bool Piece::getFirstMissingBlockIndexWithoutLock(size_t& index) const
{
return bitfield->getFirstMissingIndex(index);
}
std::deque<size_t> Piece::getAllMissingBlockIndexes() const {
return bitfield->getAllMissingIndexes(); return bitfield->getAllMissingIndexes();
} }
@ -175,7 +177,7 @@ std::string Piece::toString() const {
return "piece: index="+Util::itos(index)+", length="+Util::itos(length); return "piece: index="+Util::itos(index)+", length="+Util::itos(length);
} }
void Piece::reconfigure(int32_t length) void Piece::reconfigure(size_t length)
{ {
delete bitfield; delete bitfield;
this->length = length; this->length = length;
@ -183,12 +185,12 @@ void Piece::reconfigure(int32_t length)
BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length); BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
} }
void Piece::setBitfield(const unsigned char* bitfield, int32_t len) void Piece::setBitfield(const unsigned char* bitfield, size_t len)
{ {
this->bitfield->setBitfield(bitfield, len); this->bitfield->setBitfield(bitfield, len);
} }
int32_t Piece::getCompletedLength() size_t Piece::getCompletedLength()
{ {
return bitfield->getCompletedLength(); return bitfield->getCompletedLength();
} }

50
src/Piece.h
View File

@ -47,17 +47,17 @@ class BitfieldMan;
class Piece { class Piece {
private: private:
int32_t index; size_t index;
int32_t length; size_t length;
int32_t _blockLength; size_t _blockLength;
BitfieldMan* bitfield; BitfieldMan* bitfield;
public: public:
static const int32_t BLOCK_LENGTH = 16*1024; static const size_t BLOCK_LENGTH = 16*1024;
Piece(); Piece();
Piece(int32_t index, int32_t length, int32_t blockLength = BLOCK_LENGTH); Piece(size_t index, size_t length, size_t blockLength = BLOCK_LENGTH);
Piece(const Piece& piece); Piece(const Piece& piece);
@ -67,16 +67,16 @@ public:
bool operator==(const Piece& piece) const; bool operator==(const Piece& piece) const;
int32_t getMissingUnusedBlockIndex() const; bool getMissingUnusedBlockIndex(size_t& index) const;
int32_t getMissingBlockIndex() const; bool getMissingBlockIndex(size_t& index) const;
int32_t getFirstMissingBlockIndexWithoutLock() const; bool getFirstMissingBlockIndexWithoutLock(size_t& index) const;
std::deque<int32_t> getAllMissingBlockIndexes() const; std::deque<size_t> getAllMissingBlockIndexes() const;
void completeBlock(int32_t blockIndex); void completeBlock(size_t blockIndex);
void cancelBlock(int32_t blockIndex); void cancelBlock(size_t blockIndex);
int32_t countCompleteBlock() const; size_t countCompleteBlock() const;
bool hasBlock(int32_t blockIndex) const; bool hasBlock(size_t blockIndex) const;
/** /**
* Returns true if all blocks of this piece have been downloaded, otherwise * Returns true if all blocks of this piece have been downloaded, otherwise
@ -84,40 +84,40 @@ public:
*/ */
bool pieceComplete() const; bool pieceComplete() const;
int32_t countBlock() const; size_t countBlock() const;
int32_t getBlockLength(int32_t index) const; size_t getBlockLength(size_t index) const;
int32_t getBlockLength() const; size_t getBlockLength() const;
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
void setIndex(int32_t index) { this->index = index; } void setIndex(size_t index) { this->index = index; }
int32_t getLength() const { return length; } size_t getLength() const { return length; }
void setLength(int32_t index) { this->length = length; } void setLength(size_t index) { this->length = length; }
const unsigned char* getBitfield() const; const unsigned char* getBitfield() const;
void setBitfield(const unsigned char* bitfield, int32_t len); void setBitfield(const unsigned char* bitfield, size_t len);
int32_t getBitfieldLength() const; size_t getBitfieldLength() const;
void clearAllBlock(); void clearAllBlock();
void setAllBlock(); void setAllBlock();
std::string toString() const; std::string toString() const;
bool isBlockUsed(int32_t index) const; bool isBlockUsed(size_t index) const;
// Calculates completed length // Calculates completed length
int32_t getCompletedLength(); size_t getCompletedLength();
/** /**
* Loses current bitfield state. * Loses current bitfield state.
*/ */
void reconfigure(int32_t length); void reconfigure(size_t length);
}; };
typedef SharedHandle<Piece> PieceHandle; typedef SharedHandle<Piece> PieceHandle;

34
src/PieceStorage.h
View File

@ -88,18 +88,18 @@ public:
* then returns 0. * then returns 0.
* Also returns 0 if any of missing piece is not available. * Also returns 0 if any of missing piece is not available.
*/ */
virtual SharedHandle<Piece> getMissingPiece(int32_t index) = 0; virtual SharedHandle<Piece> getMissingPiece(size_t index) = 0;
/** /**
* Returns the piece denoted by index. * Returns the piece denoted by index.
* No status of the piece is changed in this method. * No status of the piece is changed in this method.
*/ */
virtual SharedHandle<Piece> getPiece(int32_t index) = 0; virtual SharedHandle<Piece> getPiece(size_t index) = 0;
/** /**
* Marks the piece whose index is index as missing. * Marks the piece whose index is index as missing.
*/ */
virtual void markPieceMissing(int32_t index) = 0; virtual void markPieceMissing(size_t index) = 0;
/** /**
* Tells that the download of the specfied piece completes. * Tells that the download of the specfied piece completes.
@ -115,17 +115,17 @@ public:
* Returns true if the specified piece is already downloaded. * Returns true if the specified piece is already downloaded.
* Otherwise returns false. * Otherwise returns false.
*/ */
virtual bool hasPiece(int32_t index) = 0; virtual bool hasPiece(size_t index) = 0;
virtual bool isPieceUsed(int32_t index) = 0; virtual bool isPieceUsed(size_t index) = 0;
virtual int64_t getTotalLength() = 0; virtual uint64_t getTotalLength() = 0;
virtual int64_t getFilteredTotalLength() = 0; virtual uint64_t getFilteredTotalLength() = 0;
virtual int64_t getCompletedLength() = 0; virtual uint64_t getCompletedLength() = 0;
virtual int64_t getFilteredCompletedLength() = 0; virtual uint64_t getFilteredCompletedLength() = 0;
virtual void setFileFilter(const std::deque<std::string>& filePaths) = 0; virtual void setFileFilter(const std::deque<std::string>& filePaths) = 0;
@ -155,9 +155,9 @@ public:
virtual const unsigned char* getBitfield() = 0; virtual const unsigned char* getBitfield() = 0;
virtual void setBitfield(const unsigned char* bitfield, virtual void setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength) = 0; size_t bitfieldLength) = 0;
virtual int32_t getBitfieldLength() = 0; virtual size_t getBitfieldLength() = 0;
virtual bool isSelectiveDownloadingMode() = 0; virtual bool isSelectiveDownloadingMode() = 0;
@ -167,26 +167,26 @@ public:
virtual SharedHandle<DiskAdaptor> getDiskAdaptor() = 0; virtual SharedHandle<DiskAdaptor> getDiskAdaptor() = 0;
virtual int32_t getPieceLength(int32_t index) = 0; virtual size_t getPieceLength(size_t index) = 0;
/** /**
* Adds piece index to advertise to other commands. They send have message * Adds piece index to advertise to other commands. They send have message
* based on this information. * based on this information.
*/ */
virtual void advertisePiece(int32_t cuid, int32_t index) = 0; virtual void advertisePiece(int32_t cuid, size_t index) = 0;
/** /**
* Returns piece index which is not advertised by the caller command and * Returns piece index which is not advertised by the caller command and
* newer than lastCheckTime. * newer than lastCheckTime.
*/ */
virtual std::deque<int32_t> virtual std::deque<size_t>
getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0; getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0;
/** /**
* Removes have entry if specified seconds have elapsed since its * Removes have entry if specified seconds have elapsed since its
* registration. * registration.
*/ */
virtual void removeAdvertisedPiece(int32_t elapsed) = 0; virtual void removeAdvertisedPiece(time_t elapsed) = 0;
/** /**
* Sets all bits in bitfield to 1. * Sets all bits in bitfield to 1.
@ -196,12 +196,12 @@ public:
/** /**
* Sets all bits in bitfield(0 to length) to 1. * Sets all bits in bitfield(0 to length) to 1.
*/ */
virtual void markPiecesDone(int64_t length) = 0; virtual void markPiecesDone(uint64_t length) = 0;
virtual void virtual void
addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) = 0; addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) = 0;
virtual int32_t countInFlightPiece() = 0; virtual size_t countInFlightPiece() = 0;
virtual std::deque<SharedHandle<Piece> > getInFlightPieces() = 0; virtual std::deque<SharedHandle<Piece> > getInFlightPieces() = 0;
}; };

28
src/PiecedSegment.cc
View File

@ -34,12 +34,18 @@
/* copyright --> */ /* copyright --> */
#include "PiecedSegment.h" #include "PiecedSegment.h"
#include "Piece.h" #include "Piece.h"
#include <cassert>
namespace aria2 { namespace aria2 {
PiecedSegment::PiecedSegment(int32_t pieceLength, const PieceHandle& piece): PiecedSegment::PiecedSegment(size_t pieceLength, const PieceHandle& piece):
_pieceLength(pieceLength), _overflowLength(0), _piece(piece), _pieceLength(pieceLength), _overflowLength(0), _piece(piece)
_writtenLength(_piece->getFirstMissingBlockIndexWithoutLock()*_piece->getBlockLength()) {} {
size_t index;
bool t = _piece->getFirstMissingBlockIndexWithoutLock(index);
assert(t);
_writtenLength = index*_piece->getBlockLength();
}
PiecedSegment::~PiecedSegment() {} PiecedSegment::~PiecedSegment() {}
@ -48,34 +54,34 @@ bool PiecedSegment::complete() const
return _piece->pieceComplete(); return _piece->pieceComplete();
} }
int32_t PiecedSegment::getIndex() const size_t PiecedSegment::getIndex() const
{ {
return _piece->getIndex(); return _piece->getIndex();
} }
int64_t PiecedSegment::getPosition() const off_t PiecedSegment::getPosition() const
{ {
return ((int64_t)_piece->getIndex())*_pieceLength; return ((off_t)_piece->getIndex())*_pieceLength;
} }
int64_t PiecedSegment::getPositionToWrite() const off_t PiecedSegment::getPositionToWrite() const
{ {
return getPosition()+_writtenLength; return getPosition()+_writtenLength;
} }
int32_t PiecedSegment::getLength() const size_t PiecedSegment::getLength() const
{ {
return _piece->getLength(); return _piece->getLength();
} }
void PiecedSegment::updateWrittenLength(int32_t bytes) void PiecedSegment::updateWrittenLength(size_t bytes)
{ {
int32_t newWrittenLength = _writtenLength+bytes; size_t newWrittenLength = _writtenLength+bytes;
if(newWrittenLength > _piece->getLength()) { if(newWrittenLength > _piece->getLength()) {
_overflowLength = newWrittenLength-_piece->getLength(); _overflowLength = newWrittenLength-_piece->getLength();
newWrittenLength = _piece->getLength(); newWrittenLength = _piece->getLength();
} }
for(int32_t i = _writtenLength/_piece->getBlockLength(); i < newWrittenLength/_piece->getBlockLength(); ++i) { for(size_t i = _writtenLength/_piece->getBlockLength(); i < newWrittenLength/_piece->getBlockLength(); ++i) {
_piece->completeBlock(i); _piece->completeBlock(i);
} }
if(newWrittenLength == _piece->getLength()) { if(newWrittenLength == _piece->getLength()) {

24
src/PiecedSegment.h
View File

@ -45,42 +45,42 @@ private:
* Piece class has length property but it is a actual length of piece. * Piece class has length property but it is a actual length of piece.
* The last piece likely have shorter length than the other length. * The last piece likely have shorter length than the other length.
*/ */
int32_t _pieceLength; size_t _pieceLength;
int32_t _overflowLength; size_t _overflowLength;
SharedHandle<Piece> _piece; SharedHandle<Piece> _piece;
int32_t _writtenLength; size_t _writtenLength;
public: public:
PiecedSegment(int32_t pieceLength, const SharedHandle<Piece>& piece); PiecedSegment(size_t pieceLength, const SharedHandle<Piece>& piece);
virtual ~PiecedSegment(); virtual ~PiecedSegment();
virtual bool complete() const; virtual bool complete() const;
virtual int32_t getIndex() const; virtual size_t getIndex() const;
virtual int64_t getPosition() const; virtual off_t getPosition() const;
virtual int64_t getPositionToWrite() const; virtual off_t getPositionToWrite() const;
virtual int32_t getLength() const; virtual size_t getLength() const;
virtual int32_t getSegmentLength() const virtual size_t getSegmentLength() const
{ {
return _pieceLength; return _pieceLength;
} }
virtual int32_t getWrittenLength() const virtual size_t getWrittenLength() const
{ {
return _writtenLength; return _writtenLength;
} }
virtual int32_t getOverflowLength() const virtual size_t getOverflowLength() const
{ {
return _overflowLength; return _overflowLength;
} }
virtual void updateWrittenLength(int32_t bytes); virtual void updateWrittenLength(size_t bytes);
virtual void clear(); virtual void clear();

16
src/Segment.h
View File

@ -50,21 +50,21 @@ public:
virtual bool complete() const = 0; virtual bool complete() const = 0;
virtual int32_t getIndex() const = 0; virtual size_t getIndex() const = 0;
virtual int64_t getPosition() const = 0; virtual off_t getPosition() const = 0;
virtual int64_t getPositionToWrite() const = 0; virtual off_t getPositionToWrite() const = 0;
virtual int32_t getLength() const = 0; virtual size_t getLength() const = 0;
virtual int32_t getSegmentLength() const = 0; virtual size_t getSegmentLength() const = 0;
virtual int32_t getWrittenLength() const = 0; virtual size_t getWrittenLength() const = 0;
virtual int32_t getOverflowLength() const = 0; virtual size_t getOverflowLength() const = 0;
virtual void updateWrittenLength(int32_t bytes) = 0; virtual void updateWrittenLength(size_t bytes) = 0;
virtual void clear() = 0; virtual void clear() = 0;

10
src/UnknownLengthPieceStorage.cc
View File

@ -83,7 +83,7 @@ PieceHandle UnknownLengthPieceStorage::getMissingPiece()
} }
} }
PieceHandle UnknownLengthPieceStorage::getMissingPiece(int32_t index) PieceHandle UnknownLengthPieceStorage::getMissingPiece(size_t index)
{ {
if(index == 0) { if(index == 0) {
return getMissingPiece(); return getMissingPiece();
@ -92,7 +92,7 @@ PieceHandle UnknownLengthPieceStorage::getMissingPiece(int32_t index)
} }
} }
PieceHandle UnknownLengthPieceStorage::getPiece(int32_t index) PieceHandle UnknownLengthPieceStorage::getPiece(size_t index)
{ {
if(index == 0) { if(index == 0) {
if(_piece.isNull()) { if(_piece.isNull()) {
@ -122,7 +122,7 @@ void UnknownLengthPieceStorage::cancelPiece(const PieceHandle& piece)
} }
} }
bool UnknownLengthPieceStorage::hasPiece(int32_t index) bool UnknownLengthPieceStorage::hasPiece(size_t index)
{ {
if(index == 0 && _downloadFinished) { if(index == 0 && _downloadFinished) {
return true; return true;
@ -131,7 +131,7 @@ bool UnknownLengthPieceStorage::hasPiece(int32_t index)
} }
} }
bool UnknownLengthPieceStorage::isPieceUsed(int32_t index) bool UnknownLengthPieceStorage::isPieceUsed(size_t index)
{ {
if(index == 0 && !_piece.isNull()) { if(index == 0 && !_piece.isNull()) {
return true; return true;
@ -145,7 +145,7 @@ DiskAdaptorHandle UnknownLengthPieceStorage::getDiskAdaptor()
return _diskAdaptor; return _diskAdaptor;
} }
int32_t UnknownLengthPieceStorage::getPieceLength(int32_t index) size_t UnknownLengthPieceStorage::getPieceLength(size_t index)
{ {
if(index == 0) { if(index == 0) {
return _totalLength; return _totalLength;

38
src/UnknownLengthPieceStorage.h
View File

@ -54,7 +54,7 @@ private:
SharedHandle<DiskWriterFactory> _diskWriterFactory; SharedHandle<DiskWriterFactory> _diskWriterFactory;
int64_t _totalLength; uint64_t _totalLength;
bool _downloadFinished; bool _downloadFinished;
@ -106,13 +106,13 @@ public:
* then returns 0. * then returns 0.
* Also returns 0 if any of missing piece is not available. * Also returns 0 if any of missing piece is not available.
*/ */
virtual SharedHandle<Piece> getMissingPiece(int32_t index); virtual SharedHandle<Piece> getMissingPiece(size_t index);
/** /**
* Returns the piece denoted by index. * Returns the piece denoted by index.
* No status of the piece is changed in this method. * No status of the piece is changed in this method.
*/ */
virtual SharedHandle<Piece> getPiece(int32_t index); virtual SharedHandle<Piece> getPiece(size_t index);
/** /**
* Tells that the download of the specfied piece completes. * Tells that the download of the specfied piece completes.
@ -128,27 +128,27 @@ public:
* Returns true if the specified piece is already downloaded. * Returns true if the specified piece is already downloaded.
* Otherwise returns false. * Otherwise returns false.
*/ */
virtual bool hasPiece(int32_t index); virtual bool hasPiece(size_t index);
virtual bool isPieceUsed(int32_t index); virtual bool isPieceUsed(size_t index);
virtual int64_t getTotalLength() virtual uint64_t getTotalLength()
{ {
return _totalLength; return _totalLength;
} }
virtual int64_t getFilteredTotalLength() virtual uint64_t getFilteredTotalLength()
{ {
return _totalLength; return _totalLength;
} }
virtual int64_t getCompletedLength() virtual uint64_t getCompletedLength()
{ {
// TODO we have to return actual completed length here? // TODO we have to return actual completed length here?
return _totalLength; return _totalLength;
} }
virtual int64_t getFilteredCompletedLength() virtual uint64_t getFilteredCompletedLength()
{ {
return getCompletedLength(); return getCompletedLength();
} }
@ -190,9 +190,9 @@ public:
} }
virtual void setBitfield(const unsigned char* bitfield, virtual void setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength) {} size_t bitfieldLength) {}
virtual int32_t getBitfieldLength() virtual size_t getBitfieldLength()
{ {
return 0; return 0;
} }
@ -211,42 +211,42 @@ public:
virtual SharedHandle<DiskAdaptor> getDiskAdaptor(); virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
virtual int32_t getPieceLength(int32_t index); virtual size_t getPieceLength(size_t index);
/** /**
* Adds piece index to advertise to other commands. They send have message * Adds piece index to advertise to other commands. They send have message
* based on this information. * based on this information.
*/ */
virtual void advertisePiece(int32_t cuid, int32_t index) {} virtual void advertisePiece(int32_t cuid, size_t index) {}
/** /**
* Returns piece index which is not advertised by the caller command and * Returns piece index which is not advertised by the caller command and
* newer than lastCheckTime. * newer than lastCheckTime.
*/ */
virtual std::deque<int32_t> virtual std::deque<size_t>
getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime)
{ {
return std::deque<int32_t>(); return std::deque<size_t>();
} }
/** /**
* Removes have entry if specified seconds have elapsed since its * Removes have entry if specified seconds have elapsed since its
* registration. * registration.
*/ */
virtual void removeAdvertisedPiece(int32_t elapsed) {} virtual void removeAdvertisedPiece(time_t elapsed) {}
/** /**
* Sets all bits in bitfield to 1. * Sets all bits in bitfield to 1.
*/ */
virtual void markAllPiecesDone(); virtual void markAllPiecesDone();
virtual void markPiecesDone(int64_t length) virtual void markPiecesDone(uint64_t length)
{ {
// TODO not implemented yet // TODO not implemented yet
abort(); abort();
} }
virtual void markPieceMissing(int32_t index) virtual void markPieceMissing(size_t index)
{ {
// TODO not implemented yet // TODO not implemented yet
abort(); abort();
@ -258,7 +258,7 @@ public:
*/ */
virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {} virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {}
virtual int32_t countInFlightPiece() virtual size_t countInFlightPiece()
{ {
return 0; return 0;
} }

5
src/Util.cc
View File

@ -762,8 +762,9 @@ void Util::mkdirs(const std::string& dirpath)
void Util::convertBitfield(BitfieldMan* dest, const BitfieldMan* src) void Util::convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
{ {
for(int32_t index = 0; index < dest->countBlock(); ++index) { size_t numBlock = dest->countBlock();
if(src->isBitSetOffsetRange((int64_t)index*dest->getBlockLength(), for(size_t index = 0; index < numBlock; ++index) {
if(src->isBitSetOffsetRange((uint64_t)index*dest->getBlockLength(),
dest->getBlockLength())) { dest->getBlockLength())) {
dest->setBit(index); dest->setBit(index);
} }

457
test/BitfieldManTest.cc
View File

@ -63,38 +63,64 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BitfieldManTest );
void BitfieldManTest::testGetBlockSize() { void BitfieldManTest::testGetBlockSize() {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt1.getBlockLength(9)); CPPUNIT_ASSERT_EQUAL((size_t)1024, bt1.getBlockLength(9));
BitfieldMan bt2(1024, 1024*10+1); BitfieldMan bt2(1024, 1024*10+1);
CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt2.getBlockLength(9)); CPPUNIT_ASSERT_EQUAL((size_t)1024, bt2.getBlockLength(9));
CPPUNIT_ASSERT_EQUAL((int32_t)1, bt2.getBlockLength(10)); CPPUNIT_ASSERT_EQUAL((size_t)1, bt2.getBlockLength(10));
CPPUNIT_ASSERT_EQUAL((int32_t)0, bt2.getBlockLength(11)); CPPUNIT_ASSERT_EQUAL((size_t)0, bt2.getBlockLength(11));
} }
void BitfieldManTest::testGetFirstMissingUnusedIndex() void BitfieldManTest::testGetFirstMissingUnusedIndex()
{ {
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
{
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingUnusedIndex()); size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0); bt1.setUseBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.unsetUseBit(0); bt1.unsetUseBit(0);
bt1.setBit(0); bt1.setBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit(); bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(!bt1.getFirstMissingUnusedIndex(index));
}
} }
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
bt1.addFilter(1024, 1024*10); bt1.addFilter(1024, 1024*10);
bt1.enableFilter(); bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1); bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
bt1.setBit(2); bt1.setBit(2);
CPPUNIT_ASSERT_EQUAL(3, bt1.getFirstMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
}
} }
} }
@ -102,26 +128,52 @@ void BitfieldManTest::testGetFirstMissingIndex()
{ {
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
{
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex()); size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0); bt1.setUseBit(0);
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.unsetUseBit(0); bt1.unsetUseBit(0);
bt1.setBit(0); bt1.setBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit(); bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(!bt1.getFirstMissingIndex(index));
}
} }
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
bt1.addFilter(1024, 1024*10); bt1.addFilter(1024, 1024*10);
bt1.enableFilter(); bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1); bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setBit(1); bt1.setBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
} }
} }
@ -130,15 +182,29 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer); bt1.setRandomizer(fixedNumberRandomizer);
{
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex()); size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0); bt1.setUseBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.unsetUseBit(0); bt1.unsetUseBit(0);
bt1.setBit(0); bt1.setBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit(); bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
}
} }
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
@ -146,11 +212,23 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
bt1.addFilter(1024, 1024*10); bt1.addFilter(1024, 1024*10);
bt1.enableFilter(); bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1); bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
bt1.setBit(2); bt1.setBit(2);
CPPUNIT_ASSERT_EQUAL(3, bt1.getMissingUnusedIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
}
} }
} }
@ -159,15 +237,29 @@ void BitfieldManTest::testGetMissingIndex_noarg()
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
bt1.setRandomizer(fixedNumberRandomizer); bt1.setRandomizer(fixedNumberRandomizer);
{
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex()); size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.setUseBit(0); bt1.setUseBit(0);
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
bt1.unsetUseBit(0); bt1.unsetUseBit(0);
bt1.setBit(0); bt1.setBit(0);
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setAllBit(); bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
}
} }
{ {
BitfieldMan bt1(1024, 1024*10); BitfieldMan bt1(1024, 1024*10);
@ -175,11 +267,23 @@ void BitfieldManTest::testGetMissingIndex_noarg()
bt1.addFilter(1024, 1024*10); bt1.addFilter(1024, 1024*10);
bt1.enableFilter(); bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setUseBit(1); bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
bt1.setBit(1); bt1.setBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingIndex()); {
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
} }
} }
@ -189,12 +293,12 @@ void BitfieldManTest::testIsAllBitSet() {
bt1.setBit(1); bt1.setBit(1);
CPPUNIT_ASSERT(!bt1.isAllBitSet()); CPPUNIT_ASSERT(!bt1.isAllBitSet());
for(int i = 0; i < 8; i++) { for(size_t i = 0; i < 8; i++) {
CPPUNIT_ASSERT(bt1.setBit(i)); CPPUNIT_ASSERT(bt1.setBit(i));
} }
CPPUNIT_ASSERT(!bt1.isAllBitSet()); CPPUNIT_ASSERT(!bt1.isAllBitSet());
for(int32_t i = 0; i < bt1.countBlock(); i++) { for(size_t i = 0; i < bt1.countBlock(); i++) {
CPPUNIT_ASSERT(bt1.setBit(i)); CPPUNIT_ASSERT(bt1.setBit(i));
} }
CPPUNIT_ASSERT(bt1.isAllBitSet()); CPPUNIT_ASSERT(bt1.isAllBitSet());
@ -213,29 +317,27 @@ void BitfieldManTest::testFilter() {
unsigned char peerBt[2]; unsigned char peerBt[2];
memset(peerBt, 0xff, sizeof(peerBt)); memset(peerBt, 0xff, sizeof(peerBt));
int index; size_t index;
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(2, index); CPPUNIT_ASSERT_EQUAL((size_t)2, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(3, index); CPPUNIT_ASSERT_EQUAL((size_t)3, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(4, index); CPPUNIT_ASSERT_EQUAL((size_t)4, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(5, index); CPPUNIT_ASSERT_EQUAL((size_t)5, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(6, index); CPPUNIT_ASSERT_EQUAL((size_t)6, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(7, index); CPPUNIT_ASSERT_EQUAL((size_t)7, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); CPPUNIT_ASSERT_EQUAL(12ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL(-1, index);
CPPUNIT_ASSERT_EQUAL((int64_t)12, btman.getFilteredTotalLength());
// test offset=5, length=2 // test offset=5, length=2
btman.clearAllBit(); btman.clearAllBit();
@ -243,24 +345,22 @@ void BitfieldManTest::testFilter() {
btman.clearFilter(); btman.clearFilter();
btman.addFilter(5, 2); btman.addFilter(5, 2);
btman.enableFilter(); btman.enableFilter();
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
btman.setBit(index); btman.setBit(index);
CPPUNIT_ASSERT_EQUAL(2, index); CPPUNIT_ASSERT_EQUAL((size_t)2, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); btman.setUseBit(index);
btman.setBit(index); btman.setBit(index);
CPPUNIT_ASSERT_EQUAL(3, index); CPPUNIT_ASSERT_EQUAL((size_t)3, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index); CPPUNIT_ASSERT_EQUAL(4ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL(-1, index);
CPPUNIT_ASSERT_EQUAL((int64_t)4, btman.getFilteredTotalLength());
CPPUNIT_ASSERT(btman.isFilteredAllBitSet()); CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
BitfieldMan btman2(2, 31); BitfieldMan btman2(2, 31);
btman2.addFilter(0, 31); btman2.addFilter(0, 31);
btman2.enableFilter(); btman2.enableFilter();
CPPUNIT_ASSERT_EQUAL((int64_t)31, btman2.getFilteredTotalLength()); CPPUNIT_ASSERT_EQUAL(31ULL, btman2.getFilteredTotalLength());
} }
@ -278,11 +378,14 @@ void BitfieldManTest::testGetMissingIndex() {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
}; };
CPPUNIT_ASSERT_EQUAL((int32_t)0, bt1.getMissingIndex(bitArray, 32)); size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bt1.addFilter(1024, 1024*256); bt1.addFilter(1024, 1024*256);
bt1.enableFilter(); bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL((int32_t)1, bt1.getMissingIndex(bitArray, 32)); CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bt1.disableFilter(); bt1.disableFilter();
unsigned char bitArray2[] = { unsigned char bitArray2[] = {
@ -296,7 +399,8 @@ void BitfieldManTest::testGetMissingIndex() {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
}; };
CPPUNIT_ASSERT_EQUAL((int32_t)4, bt1.getMissingIndex(bitArray2, 32)); CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray2, 32));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
unsigned char bitArray3[] = { unsigned char bitArray3[] = {
0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
@ -309,7 +413,8 @@ void BitfieldManTest::testGetMissingIndex() {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
}; };
CPPUNIT_ASSERT_EQUAL((int32_t)8, bt1.getMissingIndex(bitArray3, 32)); CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray3, 32));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
unsigned char bitArray4[] = { unsigned char bitArray4[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -322,71 +427,91 @@ void BitfieldManTest::testGetMissingIndex() {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bt1.getMissingIndex(bitArray4, 32)); CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
} }
void BitfieldManTest::testGetSparceMissingUnusedIndex() { void BitfieldManTest::testGetSparceMissingUnusedIndex() {
BitfieldMan bitfield(1024*1024, 10*1024*1024); BitfieldMan bitfield(1024*1024, 10*1024*1024);
CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex()); size_t index;
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bitfield.setUseBit(0); bitfield.setUseBit(0);
CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
bitfield.setUseBit(5); bitfield.setUseBit(5);
CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
bitfield.setUseBit(3); bitfield.setUseBit(3);
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
bitfield.setUseBit(8); bitfield.setUseBit(8);
CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bitfield.setUseBit(2); bitfield.setUseBit(2);
CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
bitfield.setUseBit(7); bitfield.setUseBit(7);
CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bitfield.setUseBit(1); bitfield.setUseBit(1);
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
bitfield.setUseBit(4); bitfield.setUseBit(4);
CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
bitfield.setUseBit(6); bitfield.setUseBit(6);
CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)9, index);
bitfield.setUseBit(9); bitfield.setUseBit(9);
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
} }
void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() { void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() {
BitfieldMan bitfield(1024*1024, 10*1024*1024); BitfieldMan bitfield(1024*1024, 10*1024*1024);
size_t index;
CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bitfield.setBit(0); bitfield.setBit(0);
CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bitfield.setBit(1); bitfield.setBit(1);
CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bitfield.setBit(2); bitfield.setBit(2);
CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
bitfield.setBit(3); bitfield.setBit(3);
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
bitfield.setBit(4); bitfield.setBit(4);
CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
bitfield.setBit(5); bitfield.setBit(5);
CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
bitfield.setBit(6); bitfield.setBit(6);
CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
bitfield.setBit(7); bitfield.setBit(7);
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
bitfield.setBit(8); bitfield.setBit(8);
CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)9, index);
bitfield.setBit(9); bitfield.setBit(9);
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex()); CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
} }
void BitfieldManTest::testIsBitSetOffsetRange() void BitfieldManTest::testIsBitSetOffsetRange()
{ {
int64_t totalLength = (int64_t)4*1024*1024*1024; int64_t totalLength = 4ULL*1024*1024*1024;
int32_t pieceLength = 4*1024*1024; int32_t pieceLength = 4*1024*1024;
BitfieldMan bitfield(pieceLength, totalLength); BitfieldMan bitfield(pieceLength, totalLength);
bitfield.setAllBit(); bitfield.setAllBit();
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0)); CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, -1));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100)); CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100)); CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100));
@ -412,91 +537,91 @@ void BitfieldManTest::testIsBitSetOffsetRange()
void BitfieldManTest::testGetMissingUnusedLength() void BitfieldManTest::testGetMissingUnusedLength()
{ {
int64_t totalLength = 1024*10+10; uint64_t totalLength = 1024*10+10;
int32_t blockLength = 1024; size_t blockLength = 1024;
BitfieldMan bf(blockLength, totalLength); BitfieldMan bf(blockLength, totalLength);
// from index 0 and all blocks are unused and not acquired. // from index 0 and all blocks are unused and not acquired.
CPPUNIT_ASSERT_EQUAL((int64_t)totalLength, bf.getMissingUnusedLength(0)); CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
// from index 10 and all blocks are unused and not acquired. // from index 10 and all blocks are unused and not acquired.
CPPUNIT_ASSERT_EQUAL((int64_t)10, bf.getMissingUnusedLength(10)); CPPUNIT_ASSERT_EQUAL(10ULL, bf.getMissingUnusedLength(10));
// from index -1 // from index -1
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(-1)); CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(-1));
// from index 11 // from index 11
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(11)); CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(11));
// from index 12 // from index 12
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(12)); CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(12));
// from index 0 and 5th block is used. // from index 0 and 5th block is used.
bf.setUseBit(5); bf.setUseBit(5);
CPPUNIT_ASSERT_EQUAL((int64_t)5*blockLength, bf.getMissingUnusedLength(0)); CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getMissingUnusedLength(0));
// from index 0 and 4th block is acquired. // from index 0 and 4th block is acquired.
bf.setBit(4); bf.setBit(4);
CPPUNIT_ASSERT_EQUAL((int64_t)4*blockLength, bf.getMissingUnusedLength(0)); CPPUNIT_ASSERT_EQUAL(4ULL*blockLength, bf.getMissingUnusedLength(0));
// from index 1 // from index 1
CPPUNIT_ASSERT_EQUAL((int64_t)3*blockLength, bf.getMissingUnusedLength(1)); CPPUNIT_ASSERT_EQUAL(3ULL*blockLength, bf.getMissingUnusedLength(1));
} }
void BitfieldManTest::testSetBitRange() void BitfieldManTest::testSetBitRange()
{ {
int32_t blockLength = 1024*1024; size_t blockLength = 1024*1024;
int64_t totalLength = 10*blockLength; uint64_t totalLength = 10*blockLength;
BitfieldMan bf(blockLength, totalLength); BitfieldMan bf(blockLength, totalLength);
bf.setBitRange(0, 4); bf.setBitRange(0, 4);
for(int32_t i = 0; i < 5; ++i) { for(size_t i = 0; i < 5; ++i) {
CPPUNIT_ASSERT(bf.isBitSet(i)); CPPUNIT_ASSERT(bf.isBitSet(i));
} }
for(int32_t i = 5; i < 10; ++i) { for(size_t i = 5; i < 10; ++i) {
CPPUNIT_ASSERT(!bf.isBitSet(i)); CPPUNIT_ASSERT(!bf.isBitSet(i));
} }
CPPUNIT_ASSERT_EQUAL(int64_t(5*blockLength), bf.getCompletedLength()); CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getCompletedLength());
} }
void BitfieldManTest::testGetAllMissingIndexes_noarg() void BitfieldManTest::testGetAllMissingIndexes_noarg()
{ {
int32_t blockLength = 16*1024; size_t blockLength = 16*1024;
int64_t totalLength = 1024*1024; uint64_t totalLength = 1024*1024;
BitfieldMan bf(blockLength, totalLength); BitfieldMan bf(blockLength, totalLength);
CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes().size()); CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes().size());
for(int32_t i = 0; i < 63; ++i) { for(size_t i = 0; i < 63; ++i) {
bf.setBit(i); bf.setBit(i);
} }
CPPUNIT_ASSERT_EQUAL((size_t)1, bf.getAllMissingIndexes().size()); CPPUNIT_ASSERT_EQUAL((size_t)1, bf.getAllMissingIndexes().size());
CPPUNIT_ASSERT_EQUAL(63, bf.getAllMissingIndexes().front()); CPPUNIT_ASSERT_EQUAL((size_t)63, bf.getAllMissingIndexes().front());
} }
void BitfieldManTest::testGetAllMissingIndexes() void BitfieldManTest::testGetAllMissingIndexes()
{ {
int32_t blockLength = 16*1024; size_t blockLength = 16*1024;
int64_t totalLength = 1024*1024; uint64_t totalLength = 1024*1024;
BitfieldMan bf(blockLength, totalLength); BitfieldMan bf(blockLength, totalLength);
BitfieldMan peerBf(blockLength, totalLength); BitfieldMan peerBf(blockLength, totalLength);
peerBf.setAllBit(); peerBf.setAllBit();
CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(), CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(),
peerBf.getBitfieldLength()).size()); peerBf.getBitfieldLength()).size());
for(int32_t i = 0; i < 62; ++i) { for(size_t i = 0; i < 62; ++i) {
bf.setBit(i); bf.setBit(i);
} }
peerBf.unsetBit(62); peerBf.unsetBit(62);
{ {
std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(), std::deque<size_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
peerBf.getBitfieldLength()); peerBf.getBitfieldLength());
CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size()); CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size());
CPPUNIT_ASSERT_EQUAL(63, indexes.front()); CPPUNIT_ASSERT_EQUAL((size_t)63, indexes.front());
} }
} }
@ -504,62 +629,68 @@ void BitfieldManTest::testGetMissingUnusedIndex()
{ {
BitfieldMan bt1(1024, 1024*256); BitfieldMan bt1(1024, 1024*256);
bt1.setRandomizer(fixedNumberRandomizer); 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);
unsigned char bitArray[] = { bt1.addFilter(1024, 1024*256);
0xff, 0xff, 0xff, 0xff, bt1.enableFilter();
0xff, 0xff, 0xff, 0xff, CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
0xff, 0xff, 0xff, 0xff, CPPUNIT_ASSERT_EQUAL((size_t)1, index);
0xff, 0xff, 0xff, 0xff, bt1.setUseBit(1);
0xff, 0xff, 0xff, 0xff, CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
0xff, 0xff, 0xff, 0xff, CPPUNIT_ASSERT_EQUAL((size_t)2, index);
0xff, 0xff, 0xff, 0xff, bt1.disableFilter();
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.addFilter(1024, 1024*256); bt1.setBit(0);
bt1.enableFilter(); CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex(bitArray, 32)); CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.disableFilter();
bt1.setBit(0); bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32)); CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
bt1.setAllBit(); bt1.clearAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32)); bt1.setAllUseBit();
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
bt1.clearAllBit(); }
bt1.setAllUseBit(); {
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32)); unsigned char bitArray4[] = {
0x00, 0x00, 0x00, 0x00,
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, 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));
}; }
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray4, 32));
} }
void BitfieldManTest::testCountFilteredBlock() void BitfieldManTest::testCountFilteredBlock()
{ {
BitfieldMan bt(1024, 1024*256); BitfieldMan bt(1024, 1024*256);
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock()); CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock()); CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
bt.addFilter(1024, 1024*256); bt.addFilter(1024, 1024*256);
bt.enableFilter(); bt.enableFilter();
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock()); CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(255, bt.countFilteredBlock()); CPPUNIT_ASSERT_EQUAL((size_t)255, bt.countFilteredBlock());
bt.disableFilter(); bt.disableFilter();
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock()); CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock()); CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
} }
} // namespace aria2 } // namespace aria2

2
test/BtRequestMessageTest.cc
View File

@ -54,7 +54,7 @@ public:
class MockPieceStorage2 : public MockPieceStorage { class MockPieceStorage2 : public MockPieceStorage {
public: public:
virtual bool hasPiece(int index) { virtual bool hasPiece(size_t index) {
return index == 1; return index == 1;
} }
}; };

10
test/DefaultBtMessageDispatcherTest.cc
View File

@ -111,7 +111,7 @@ public:
private: private:
SharedHandle<Piece> piece; SharedHandle<Piece> piece;
public: public:
virtual SharedHandle<Piece> getPiece(int index) { virtual SharedHandle<Piece> getPiece(size_t index) {
return piece; return piece;
} }
@ -281,7 +281,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0); RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH); SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
assert(piece->getMissingUnusedBlockIndex() == 0); size_t index;
CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2(); SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
pieceStorage->setPiece(piece); pieceStorage->setPiece(piece);
@ -308,7 +310,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
slot.setDispatchedTime(0); slot.setDispatchedTime(0);
SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH); SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
assert(piece->getMissingUnusedBlockIndex() == 0); size_t index;
CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2(); SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
pieceStorage->setPiece(piece); pieceStorage->setPiece(piece);

114
test/DefaultBtProgressInfoFileTest.cc
View File

@ -110,22 +110,22 @@ void DefaultBtProgressInfoFileTest::testLoad()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength())); Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces // the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)2, CPPUNIT_ASSERT_EQUAL((size_t)2,
_pieceStorage->countInFlightPiece()); _pieceStorage->countInFlightPiece());
// piece index 1 // piece index 1
std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces(); std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
SharedHandle<Piece> piece1 = inFlightPieces[0]; SharedHandle<Piece> piece1 = inFlightPieces[0];
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength()); CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(), CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
piece1->getBitfieldLength())); piece1->getBitfieldLength()));
// piece index 2 // piece index 2
SharedHandle<Piece> piece2 = inFlightPieces[1]; SharedHandle<Piece> piece2 = inFlightPieces[1];
CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
} }
void DefaultBtProgressInfoFileTest::testLoad_nonBt() void DefaultBtProgressInfoFileTest::testLoad_nonBt()
@ -146,22 +146,22 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength())); Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces // the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)2, CPPUNIT_ASSERT_EQUAL((size_t)2,
_pieceStorage->countInFlightPiece()); _pieceStorage->countInFlightPiece());
// piece index 1 // piece index 1
std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces(); std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
SharedHandle<Piece> piece1 = inFlightPieces[0]; SharedHandle<Piece> piece1 = inFlightPieces[0];
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength()); CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(), CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
piece1->getBitfieldLength())); piece1->getBitfieldLength()));
// piece index 2 // piece index 2
SharedHandle<Piece> piece2 = inFlightPieces[1]; SharedHandle<Piece> piece2 = inFlightPieces[1];
CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
} }
@ -184,7 +184,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength())); Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces // the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)0, CPPUNIT_ASSERT_EQUAL((size_t)0,
_pieceStorage->countInFlightPiece()); _pieceStorage->countInFlightPiece());
} }
@ -224,47 +224,47 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
in.read((char*)extension, sizeof(extension)); in.read((char*)extension, sizeof(extension));
CPPUNIT_ASSERT_EQUAL(std::string("00000000"), Util::toHex(extension, sizeof(extension))); CPPUNIT_ASSERT_EQUAL(std::string("00000000"), Util::toHex(extension, sizeof(extension)));
int32_t infoHashLength; uint32_t infoHashLength;
in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength)); in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
CPPUNIT_ASSERT_EQUAL((int32_t)0, infoHashLength); CPPUNIT_ASSERT_EQUAL((uint32_t)0, infoHashLength);
int32_t pieceLength; uint32_t pieceLength;
in.read((char*)&pieceLength, sizeof(pieceLength)); in.read((char*)&pieceLength, sizeof(pieceLength));
CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength); CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
int64_t totalLength; uint64_t totalLength;
in.read((char*)&totalLength, sizeof(totalLength)); in.read((char*)&totalLength, sizeof(totalLength));
CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength); CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
int64_t uploadLength; uint64_t uploadLength;
in.read((char*)&uploadLength, sizeof(uploadLength)); in.read((char*)&uploadLength, sizeof(uploadLength));
CPPUNIT_ASSERT_EQUAL((int64_t)0, uploadLength); CPPUNIT_ASSERT_EQUAL((uint64_t)0, uploadLength);
int32_t bitfieldLength; uint32_t bitfieldLength;
in.read((char*)&bitfieldLength, sizeof(bitfieldLength)); in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength); CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
unsigned char bitfieldRead[10]; unsigned char bitfieldRead[10];
in.read((char*)bitfieldRead, sizeof(bitfieldRead)); in.read((char*)bitfieldRead, sizeof(bitfieldRead));
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
Util::toHex(bitfieldRead, sizeof(bitfieldRead))); Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
int32_t numInFlightPiece; uint32_t numInFlightPiece;
in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece)); in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece); CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
// piece index 1 // piece index 1
int32_t index1; uint32_t index1;
in.read((char*)&index1, sizeof(index1)); in.read((char*)&index1, sizeof(index1));
CPPUNIT_ASSERT_EQUAL((int32_t)1, index1); CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
int32_t pieceLength1; uint32_t pieceLength1;
in.read((char*)&pieceLength1, sizeof(pieceLength1)); in.read((char*)&pieceLength1, sizeof(pieceLength1));
CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1); CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
int32_t pieceBitfieldLength1; uint32_t pieceBitfieldLength1;
in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1)); in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1); CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
unsigned char pieceBitfield1[1]; unsigned char pieceBitfield1[1];
in.read((char*)pieceBitfield1, sizeof(pieceBitfield1)); in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@ -272,13 +272,13 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
Util::toHex(pieceBitfield1, sizeof(pieceBitfield1))); Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
// piece index 2 // piece index 2
int32_t index2; uint32_t index2;
in.read((char*)&index2, sizeof(index2)); in.read((char*)&index2, sizeof(index2));
CPPUNIT_ASSERT_EQUAL((int32_t)2, index2); CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
int32_t pieceLength2; uint32_t pieceLength2;
in.read((char*)&pieceLength2, sizeof(pieceLength2)); in.read((char*)&pieceLength2, sizeof(pieceLength2));
CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2); CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
} }
@ -321,52 +321,52 @@ void DefaultBtProgressInfoFileTest::testSave()
in.read((char*)extension, sizeof(extension)); in.read((char*)extension, sizeof(extension));
CPPUNIT_ASSERT_EQUAL(std::string("00000001"), Util::toHex(extension, sizeof(extension))); CPPUNIT_ASSERT_EQUAL(std::string("00000001"), Util::toHex(extension, sizeof(extension)));
int32_t infoHashLength; uint32_t infoHashLength;
in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength)); in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
CPPUNIT_ASSERT_EQUAL((int32_t)20, infoHashLength); CPPUNIT_ASSERT_EQUAL((uint32_t)20, infoHashLength);
unsigned char infoHashRead[20]; unsigned char infoHashRead[20];
in.read((char*)infoHashRead, sizeof(infoHashRead)); in.read((char*)infoHashRead, sizeof(infoHashRead));
CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"), CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"),
Util::toHex(infoHashRead, sizeof(infoHashRead))); Util::toHex(infoHashRead, sizeof(infoHashRead)));
int32_t pieceLength; uint32_t pieceLength;
in.read((char*)&pieceLength, sizeof(pieceLength)); in.read((char*)&pieceLength, sizeof(pieceLength));
CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength); CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
int64_t totalLength; uint64_t totalLength;
in.read((char*)&totalLength, sizeof(totalLength)); in.read((char*)&totalLength, sizeof(totalLength));
CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength); CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
int64_t uploadLength; uint64_t uploadLength;
in.read((char*)&uploadLength, sizeof(uploadLength)); in.read((char*)&uploadLength, sizeof(uploadLength));
CPPUNIT_ASSERT_EQUAL((int64_t)1024, uploadLength); CPPUNIT_ASSERT_EQUAL((uint64_t)1024, uploadLength);
int32_t bitfieldLength; uint32_t bitfieldLength;
in.read((char*)&bitfieldLength, sizeof(bitfieldLength)); in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength); CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
unsigned char bitfieldRead[10]; unsigned char bitfieldRead[10];
in.read((char*)bitfieldRead, sizeof(bitfieldRead)); in.read((char*)bitfieldRead, sizeof(bitfieldRead));
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
Util::toHex(bitfieldRead, sizeof(bitfieldRead))); Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
int32_t numInFlightPiece; uint32_t numInFlightPiece;
in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece)); in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece); CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
// piece index 1 // piece index 1
int32_t index1; uint32_t index1;
in.read((char*)&index1, sizeof(index1)); in.read((char*)&index1, sizeof(index1));
CPPUNIT_ASSERT_EQUAL((int32_t)1, index1); CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
int32_t pieceLength1; uint32_t pieceLength1;
in.read((char*)&pieceLength1, sizeof(pieceLength1)); in.read((char*)&pieceLength1, sizeof(pieceLength1));
CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1); CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
int32_t pieceBitfieldLength1; uint32_t pieceBitfieldLength1;
in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1)); in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1); CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
unsigned char pieceBitfield1[1]; unsigned char pieceBitfield1[1];
in.read((char*)pieceBitfield1, sizeof(pieceBitfield1)); in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@ -374,13 +374,13 @@ void DefaultBtProgressInfoFileTest::testSave()
Util::toHex(pieceBitfield1, sizeof(pieceBitfield1))); Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
// piece index 2 // piece index 2
int32_t index2; uint32_t index2;
in.read((char*)&index2, sizeof(index2)); in.read((char*)&index2, sizeof(index2));
CPPUNIT_ASSERT_EQUAL((int32_t)2, index2); CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
int32_t pieceLength2; uint32_t pieceLength2;
in.read((char*)&pieceLength2, sizeof(pieceLength2)); in.read((char*)&pieceLength2, sizeof(pieceLength2));
CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2); CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
} }

32
test/DefaultBtRequestFactoryTest.cc
View File

@ -39,10 +39,10 @@ public:
class MockBtRequestMessage : public MockBtMessage { class MockBtRequestMessage : public MockBtMessage {
public: public:
int index; size_t index;
int blockIndex; size_t blockIndex;
MockBtRequestMessage(int index, int blockIndex):index(index), blockIndex(blockIndex) {} MockBtRequestMessage(size_t index, size_t blockIndex):index(index), blockIndex(blockIndex) {}
}; };
typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle; typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle;
@ -126,7 +126,7 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
CPPUNIT_ASSERT_EQUAL((int32_t)2, btRequestFactory->countTargetPiece()); CPPUNIT_ASSERT_EQUAL((int32_t)2, btRequestFactory->countTargetPiece());
btRequestFactory->removeCompletedPiece(); btRequestFactory->removeCompletedPiece();
CPPUNIT_ASSERT_EQUAL((int32_t)1, btRequestFactory->countTargetPiece()); CPPUNIT_ASSERT_EQUAL((int32_t)1, btRequestFactory->countTargetPiece());
CPPUNIT_ASSERT_EQUAL((int32_t)0, btRequestFactory->getTargetPieces().front()->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, btRequestFactory->getTargetPieces().front()->getIndex());
} }
void DefaultBtRequestFactoryTest::testCreateRequestMessages() { void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
@ -141,16 +141,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size()); CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin(); std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get(); MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
++itr; ++itr;
msg = (MockBtRequestMessage*)itr->get(); msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
++itr; ++itr;
msg = (MockBtRequestMessage*)itr->get(); msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)1, btRequestFactory->createRequestMessages(3).size()); CPPUNIT_ASSERT_EQUAL((size_t)1, btRequestFactory->createRequestMessages(3).size());
} }
@ -173,16 +173,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size()); CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin(); std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get(); MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
++itr; ++itr;
msg = (MockBtRequestMessage*)itr->get(); msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
++itr; ++itr;
msg = (MockBtRequestMessage*)itr->get(); msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex); CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
} }
void DefaultBtRequestFactoryTest::testRemoveTargetPiece() { void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {

42
test/DefaultPieceStorageTest.cc
View File

@ -71,8 +71,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
void DefaultPieceStorageTest::testGetTotalLength() { void DefaultPieceStorageTest::testGetTotalLength() {
DefaultPieceStorage pss(btContext, option); DefaultPieceStorage pss(btContext, option);
CPPUNIT_ASSERT_EQUAL((long long int)384, CPPUNIT_ASSERT_EQUAL(384ULL, pss.getTotalLength());
pss.getTotalLength());
} }
void DefaultPieceStorageTest::testGetMissingPiece() { void DefaultPieceStorageTest::testGetMissingPiece() {
@ -126,26 +125,23 @@ void DefaultPieceStorageTest::testCompletePiece() {
CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"), CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
piece->toString()); piece->toString());
CPPUNIT_ASSERT_EQUAL((int64_t)0, CPPUNIT_ASSERT_EQUAL(0ULL, pss.getCompletedLength());
pss.getCompletedLength());
pss.completePiece(piece); pss.completePiece(piece);
CPPUNIT_ASSERT_EQUAL((int64_t)128, CPPUNIT_ASSERT_EQUAL(128ULL, pss.getCompletedLength());
pss.getCompletedLength());
SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer); SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer);
incompletePiece->completeBlock(0); incompletePiece->completeBlock(0);
CPPUNIT_ASSERT_EQUAL((int64_t)256, CPPUNIT_ASSERT_EQUAL(256ULL, pss.getCompletedLength());
pss.getCompletedLength());
} }
void DefaultPieceStorageTest::testGetPiece() { void DefaultPieceStorageTest::testGetPiece() {
DefaultPieceStorage pss(btContext, option); DefaultPieceStorage pss(btContext, option);
SharedHandle<Piece> pieceGot = pss.getPiece(0); SharedHandle<Piece> pieceGot = pss.getPiece(0);
CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete()); CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete());
} }
@ -155,9 +151,9 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
piece->completeBlock(0); piece->completeBlock(0);
pss.addUsedPiece(piece); pss.addUsedPiece(piece);
SharedHandle<Piece> pieceGot = pss.getPiece(0); SharedHandle<Piece> pieceGot = pss.getPiece(0);
CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceGot->countCompleteBlock()); CPPUNIT_ASSERT_EQUAL((size_t)1, pieceGot->countCompleteBlock());
} }
void DefaultPieceStorageTest::testGetPieceCompletedPiece() { void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
@ -165,15 +161,15 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128)); SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
pss.completePiece(piece); pss.completePiece(piece);
SharedHandle<Piece> pieceGot = pss.getPiece(0); SharedHandle<Piece> pieceGot = pss.getPiece(0);
CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete()); CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete());
} }
void DefaultPieceStorageTest::testCancelPiece() void DefaultPieceStorageTest::testCancelPiece()
{ {
int32_t pieceLength = 256*1024; size_t pieceLength = 256*1024;
int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM uint64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
std::deque<std::string> uris1; std::deque<std::string> uris1;
uris1.push_back("http://localhost/src/file1.txt"); uris1.push_back("http://localhost/src/file1.txt");
SharedHandle<FileEntry> file1 = new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/); SharedHandle<FileEntry> file1 = new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/);
@ -197,8 +193,8 @@ void DefaultPieceStorageTest::testCancelPiece()
void DefaultPieceStorageTest::testMarkPiecesDone() void DefaultPieceStorageTest::testMarkPiecesDone()
{ {
int32_t pieceLength = 256*1024; size_t pieceLength = 256*1024;
int64_t totalLength = 4*1024*1024; uint64_t totalLength = 4*1024*1024;
SharedHandle<MockBtContext> dctx = new MockBtContext(); SharedHandle<MockBtContext> dctx = new MockBtContext();
dctx->setPieceLength(pieceLength); dctx->setPieceLength(pieceLength);
dctx->setTotalLength(totalLength); dctx->setTotalLength(totalLength);
@ -207,17 +203,17 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
ps.markPiecesDone(pieceLength*10+16*1024*2+1); ps.markPiecesDone(pieceLength*10+16*1024*2+1);
for(int32_t i = 0; i < 10; ++i) { for(size_t i = 0; i < 10; ++i) {
CPPUNIT_ASSERT(ps.hasPiece(i)); CPPUNIT_ASSERT(ps.hasPiece(i));
} }
for(int32_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) { for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
CPPUNIT_ASSERT(!ps.hasPiece(i)); CPPUNIT_ASSERT(!ps.hasPiece(i));
} }
CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength*10+16*1024*2, ps.getCompletedLength()); CPPUNIT_ASSERT_EQUAL((uint64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
ps.markPiecesDone(totalLength); ps.markPiecesDone(totalLength);
for(int32_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) { for(size_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
CPPUNIT_ASSERT(ps.hasPiece(i)); CPPUNIT_ASSERT(ps.hasPiece(i));
} }
} }

6
test/GrowSegmentTest.cc
View File

@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
GrowSegment segment(new Piece()); GrowSegment segment(new Piece());
segment.updateWrittenLength(32*1024); segment.updateWrittenLength(32*1024);
CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite()); CPPUNIT_ASSERT_EQUAL((off_t)32*1024, segment.getPositionToWrite());
CPPUNIT_ASSERT(!segment.complete()); CPPUNIT_ASSERT(!segment.complete());
CPPUNIT_ASSERT(segment.getPiece()->pieceComplete()); CPPUNIT_ASSERT(segment.getPiece()->pieceComplete());
} }
@ -36,9 +36,9 @@ void GrowSegmentTest::testClear()
{ {
GrowSegment segment(new Piece()); GrowSegment segment(new Piece());
segment.updateWrittenLength(32*1024); segment.updateWrittenLength(32*1024);
CPPUNIT_ASSERT_EQUAL((int32_t)32*1024, segment.getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)32*1024, segment.getWrittenLength());
segment.clear(); segment.clear();
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment.getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, segment.getWrittenLength());
} }
} // namespace aria2 } // namespace aria2

4
test/MockBtRequestFactory.h
View File

@ -22,10 +22,10 @@ public:
virtual void doChokedAction() {} virtual void doChokedAction() {}
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessages(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); } createRequestMessages(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
virtual std::deque<SharedHandle<BtMessage> > virtual std::deque<SharedHandle<BtMessage> >
createRequestMessagesOnEndGame(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); } createRequestMessagesOnEndGame(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
}; };
} // namespace aria2 } // namespace aria2

58
test/MockPieceStorage.h
View File

@ -11,15 +11,15 @@ namespace aria2 {
class MockPieceStorage : public PieceStorage { class MockPieceStorage : public PieceStorage {
private: private:
int64_t totalLength; uint64_t totalLength;
int64_t filteredTotalLength; uint64_t filteredTotalLength;
int64_t completedLength; uint64_t completedLength;
int64_t filteredCompletedLength; uint64_t filteredCompletedLength;
BitfieldMan* bitfieldMan; BitfieldMan* bitfieldMan;
bool selectiveDownloadingMode; bool selectiveDownloadingMode;
bool endGame; bool endGame;
SharedHandle<DiskAdaptor> diskAdaptor; SharedHandle<DiskAdaptor> diskAdaptor;
std::deque<int32_t> pieceLengthList; std::deque<size_t> pieceLengthList;
std::deque<SharedHandle<Piece> > inFlightPieces; std::deque<SharedHandle<Piece> > inFlightPieces;
bool _allDownloadFinished; bool _allDownloadFinished;
public: public:
@ -52,21 +52,21 @@ public:
return new Piece(); return new Piece();
} }
virtual SharedHandle<Piece> getMissingPiece(int32_t index) virtual SharedHandle<Piece> getMissingPiece(size_t index)
{ {
return new Piece(); return new Piece();
} }
virtual bool isPieceUsed(int32_t index) virtual bool isPieceUsed(size_t index)
{ {
return false; return false;
} }
virtual void markPieceMissing(int32_t index) {} virtual void markPieceMissing(size_t index) {}
virtual void markPiecesDone(int64_t) {} virtual void markPiecesDone(uint64_t) {}
virtual SharedHandle<Piece> getPiece(int32_t index) { virtual SharedHandle<Piece> getPiece(size_t index) {
return new Piece(); return new Piece();
} }
@ -74,39 +74,39 @@ public:
virtual void cancelPiece(const SharedHandle<Piece>& piece) {} virtual void cancelPiece(const SharedHandle<Piece>& piece) {}
virtual bool hasPiece(int32_t index) { virtual bool hasPiece(size_t index) {
return false; return false;
} }
virtual int64_t getTotalLength() { virtual uint64_t getTotalLength() {
return totalLength; return totalLength;
} }
void setTotalLength(int64_t totalLength) { void setTotalLength(uint64_t totalLength) {
this->totalLength = totalLength; this->totalLength = totalLength;
} }
virtual int64_t getFilteredTotalLength() { virtual uint64_t getFilteredTotalLength() {
return filteredTotalLength; return filteredTotalLength;
} }
void setFilteredTotalLength(int64_t totalLength) { void setFilteredTotalLength(uint64_t totalLength) {
this->filteredTotalLength = totalLength; this->filteredTotalLength = totalLength;
} }
virtual int64_t getCompletedLength() { virtual uint64_t getCompletedLength() {
return completedLength; return completedLength;
} }
void setCompletedLength(int64_t completedLength) { void setCompletedLength(uint64_t completedLength) {
this->completedLength = completedLength; this->completedLength = completedLength;
} }
virtual int64_t getFilteredCompletedLength() { virtual uint64_t getFilteredCompletedLength() {
return filteredCompletedLength; return filteredCompletedLength;
} }
void setFilteredCompletedLength(int64_t completedLength) { void setFilteredCompletedLength(uint64_t completedLength) {
this->filteredCompletedLength = completedLength; this->filteredCompletedLength = completedLength;
} }
@ -136,11 +136,11 @@ public:
} }
virtual void setBitfield(const unsigned char* bitfield, virtual void setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength) { size_t bitfieldLength) {
bitfieldMan->setBitfield(bitfield, bitfieldLength); bitfieldMan->setBitfield(bitfield, bitfieldLength);
} }
virtual int32_t getBitfieldLength() { virtual size_t getBitfieldLength() {
return bitfieldMan->getBitfieldLength(); return bitfieldMan->getBitfieldLength();
} }
@ -174,22 +174,22 @@ public:
this->diskAdaptor = adaptor; this->diskAdaptor = adaptor;
} }
virtual int32_t getPieceLength(int32_t index) { virtual size_t getPieceLength(size_t index) {
return pieceLengthList.at(index); return pieceLengthList.at(index);
} }
void addPieceLengthList(int32_t length) { void addPieceLengthList(size_t length) {
pieceLengthList.push_back(length); pieceLengthList.push_back(length);
} }
virtual void advertisePiece(int32_t cuid, int32_t index) {} virtual void advertisePiece(int32_t cuid, size_t index) {}
virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid, virtual std::deque<size_t> getAdvertisedPieceIndexes(int32_t myCuid,
const Time& lastCheckTime) { const Time& lastCheckTime) {
return std::deque<int32_t>(); return std::deque<size_t>();
} }
virtual void removeAdvertisedPiece(int32_t elapsed) {} virtual void removeAdvertisedPiece(time_t elapsed) {}
virtual void markAllPiecesDone() {} virtual void markAllPiecesDone() {}
@ -198,7 +198,7 @@ public:
std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces)); std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
} }
virtual int32_t countInFlightPiece() virtual size_t countInFlightPiece()
{ {
return inFlightPieces.size(); return inFlightPieces.size();
} }

2
test/PieceTest.cc
View File

@ -42,7 +42,7 @@ void PieceTest::testGetCompletedLength()
p.completeBlock(9); p.completeBlock(9);
p.completeBlock(10); // <-- 100 bytes p.completeBlock(10); // <-- 100 bytes
CPPUNIT_ASSERT_EQUAL(blockLength*3+100, p.getCompletedLength()); CPPUNIT_ASSERT_EQUAL((size_t)blockLength*3+100, p.getCompletedLength());
} }
} // namespace aria2 } // namespace aria2

16
test/SegmentManTest.cc
View File

@ -43,10 +43,10 @@ void SegmentManTest::testNullBitfield()
SharedHandle<Segment> segment = segmentMan.getSegment(1); SharedHandle<Segment> segment = segmentMan.getSegment(1);
CPPUNIT_ASSERT(!segment.isNull()); CPPUNIT_ASSERT(!segment.isNull());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getSegmentLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getSegmentLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getWrittenLength());
SharedHandle<Segment> segment2 = segmentMan.getSegment(2); SharedHandle<Segment> segment2 = segmentMan.getSegment(2);
CPPUNIT_ASSERT(segment2.isNull()); CPPUNIT_ASSERT(segment2.isNull());
@ -58,8 +58,8 @@ void SegmentManTest::testNullBitfield()
void SegmentManTest::testCompleteSegment() void SegmentManTest::testCompleteSegment()
{ {
Option op; Option op;
int32_t pieceLength = 1024*1024; size_t pieceLength = 1024*1024;
int64_t totalLength = 64*1024*1024; uint64_t totalLength = 64*1024*1024;
SharedHandle<MockBtContext> dctx = new MockBtContext(); SharedHandle<MockBtContext> dctx = new MockBtContext();
dctx->setPieceLength(pieceLength); dctx->setPieceLength(pieceLength);
dctx->setTotalLength(totalLength); dctx->setTotalLength(totalLength);
@ -78,8 +78,8 @@ void SegmentManTest::testCompleteSegment()
std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1); std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1);
CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size()); CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
CPPUNIT_ASSERT_EQUAL(0, segments[0]->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
CPPUNIT_ASSERT_EQUAL(2, segments[1]->getIndex()); CPPUNIT_ASSERT_EQUAL((size_t)2, segments[1]->getIndex());
} }
void SegmentManTest::testMarkPieceDone_usedSegment() void SegmentManTest::testMarkPieceDone_usedSegment()

12
test/SegmentTest.cc
View File

@ -32,7 +32,7 @@ void SegmentTest::testUpdateWrittenLength()
{ {
SharedHandle<Piece> p = new Piece(0, 16*1024*10); SharedHandle<Piece> p = new Piece(0, 16*1024*10);
PiecedSegment s(16*1024*10, p); PiecedSegment s(16*1024*10, p);
CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
s.updateWrittenLength(16*1024); s.updateWrittenLength(16*1024);
CPPUNIT_ASSERT(p->hasBlock(0)); CPPUNIT_ASSERT(p->hasBlock(0));
@ -49,7 +49,7 @@ void SegmentTest::testUpdateWrittenLength_overflow()
s.updateWrittenLength(16*1024*11); s.updateWrittenLength(16*1024*11);
CPPUNIT_ASSERT(p->pieceComplete()); CPPUNIT_ASSERT(p->pieceComplete());
CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength()); CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
} }
void SegmentTest::testUpdateWrittenLength_lastPiece() void SegmentTest::testUpdateWrittenLength_lastPiece()
@ -77,11 +77,11 @@ void SegmentTest::testClear()
SharedHandle<Piece> p = new Piece(0, 16*1024*10); SharedHandle<Piece> p = new Piece(0, 16*1024*10);
PiecedSegment s(16*1024*10, p); PiecedSegment s(16*1024*10, p);
s.updateWrittenLength(16*1024*11); s.updateWrittenLength(16*1024*11);
CPPUNIT_ASSERT_EQUAL((int32_t)16*1024*10, s.getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)16*1024*10, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength()); CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
s.clear(); s.clear();
CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getOverflowLength()); CPPUNIT_ASSERT_EQUAL((size_t)0, s.getOverflowLength());
} }
} // namespace aria2 } // namespace aria2