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>
Fixed compilation error with --disable-nls

287
src/BitfieldMan.cc
View File

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

129
src/BitfieldMan.h
View File

@ -45,121 +45,120 @@ class Randomizer;
class BitfieldMan {
private:
int32_t blockLength;
int64_t totalLength;
size_t blockLength;
uint64_t totalLength;
unsigned char* bitfield;
unsigned char* useBitfield;
unsigned char* filterBitfield;
int32_t bitfieldLength;
int32_t blocks;
size_t bitfieldLength;
size_t blocks;
bool filterEnabled;
SharedHandle<Randomizer> randomizer;
// for caching
int32_t cachedNumMissingBlock;
int32_t cachedNumFilteredBlock;
int64_t cachedCompletedLength;
int64_t cachedFilteredComletedLength;
int64_t cachedFilteredTotalLength;
size_t cachedNumMissingBlock;
size_t cachedNumFilteredBlock;
uint64_t cachedCompletedLength;
uint64_t cachedFilteredComletedLength;
uint64_t cachedFilteredTotalLength;
int32_t countSetBit(const unsigned char* bitfield, int32_t len) const;
int32_t getNthBitIndex(const unsigned char bit, int32_t nth) const;
int32_t getMissingIndexRandomly(const unsigned char* bitfield, int32_t len) const;
size_t countSetBit(const unsigned char* bitfield, size_t len) const;
size_t getNthBitIndex(const unsigned char bit, size_t nth) const;
bool getMissingIndexRandomly(size_t& index, const unsigned char* bitfield, size_t len) const;
template<typename Array>
int32_t
getMissingIndexRandomly(const Array& bitfield,
int32_t bitfieldLength) const;
bool getMissingIndexRandomly(size_t& index, const Array& bitfield,
size_t bitfieldLength) const;
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>
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 setBitInternal(unsigned char* bitfield, int32_t index, bool on);
bool setFilterBit(int32_t index);
bool isBitSetInternal(const unsigned char* bitfield, size_t index) const;
bool setBitInternal(unsigned char* bitfield, size_t index, bool on);
bool setFilterBit(size_t index);
int32_t getStartIndex(int32_t index) const;
int32_t getEndIndex(int32_t index) const;
size_t getStartIndex(size_t index) const;
size_t getEndIndex(size_t index) const;
int64_t getCompletedLength(bool useFilter) const;
uint64_t getCompletedLength(bool useFilter) const;
public:
BitfieldMan(int32_t blockLength, int64_t totalLength);
BitfieldMan(size_t blockLength, uint64_t totalLength);
BitfieldMan(const BitfieldMan& 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
*/
bool hasMissingPiece(const unsigned char* bitfield, int32_t len) const;
bool hasMissingPiece(const unsigned char* bitfield, size_t len) const;
/**
* 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
*/
int32_t getMissingIndex() const;
bool getMissingIndex(size_t& index) const;
/**
* 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
*/
int32_t getFirstMissingUnusedIndex() const;
bool getFirstMissingUnusedIndex(size_t& index) const;
/**
* affected by filter
*/
int32_t getFirstMissingIndex() const;
bool getFirstMissingIndex(size_t& index) const;
/**
* 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
*/
int32_t getMissingUnusedIndex() const;
bool getMissingUnusedIndex(size_t& index) const;
/**
* affected by filter
*/
int32_t getSparseMissingUnusedIndex() const;
bool getSparseMissingUnusedIndex(size_t& index) const;
/**
* affected by filter
*/
std::deque<int32_t> getAllMissingIndexes() const;
std::deque<size_t> getAllMissingIndexes() const;
/**
* 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
*/
int32_t countMissingBlock() const;
size_t countMissingBlock() const;
/**
* affected by filter
*/
int32_t countMissingBlockNow() const;
size_t countMissingBlockNow() const;
bool setUseBit(int32_t index);
bool unsetUseBit(int32_t index);
bool setUseBit(size_t index);
bool unsetUseBit(size_t index);
bool setBit(int32_t index);
bool unsetBit(int32_t index);
bool setBit(size_t index);
bool unsetBit(size_t index);
bool isBitSet(int32_t index) const;
bool isUseBitSet(int32_t index) const;
bool isBitSet(size_t index) const;
bool isUseBitSet(size_t index) const;
/**
* affected by filter
@ -170,22 +169,22 @@ public:
const unsigned char* getBitfield() const;
int32_t getBitfieldLength() const;
size_t getBitfieldLength() const;
/**
* affected by filter
*/
int32_t countFilteredBlock() const;
size_t countFilteredBlock() const;
int32_t countBlock() const;
size_t countBlock() const;
/**
* 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 setAllBit();
@ -193,7 +192,7 @@ public:
void clearAllUseBit();
void setAllUseBit();
void addFilter(int64_t offset, int64_t length);
void addFilter(uint64_t offset, uint64_t length);
/**
* Clears filter and disables filter
*/
@ -205,24 +204,24 @@ public:
/**
* affected by filter
*/
int64_t getFilteredTotalLength() const;
uint64_t getFilteredTotalLength() const;
/**
* 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
*/
int64_t getFilteredCompletedLength() const;
uint64_t getFilteredCompletedLength() const;
/**
* affected by filter
*/
int64_t getFilteredCompletedLengthNow() const;
uint64_t getFilteredCompletedLengthNow() const;
void setRandomizer(const SharedHandle<Randomizer>& randomizer);
@ -230,15 +229,15 @@ public:
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.
*/
virtual std::deque<SharedHandle<BtMessage> >
createRequestMessages(int32_t max) = 0;
createRequestMessages(size_t max) = 0;
/**
* Use this method in end game mode.
*
*/
virtual std::deque<SharedHandle<BtMessage> >
createRequestMessagesOnEndGame(int32_t max) = 0;
createRequestMessagesOnEndGame(size_t max) = 0;
};
typedef SharedHandle<BtRequestFactory> BtRequestFactoryHandle;

4
src/DefaultBtInteractive.cc
View File

@ -199,7 +199,7 @@ void DefaultBtInteractive::decideChoking() {
}
void DefaultBtInteractive::checkHave() {
std::deque<int32_t> indexes =
std::deque<size_t> indexes =
pieceStorage->getAdvertisedPieceIndexes(cuid, haveCheckPoint);
haveCheckPoint.reset();
if(indexes.size() >= 20) {
@ -209,7 +209,7 @@ void DefaultBtInteractive::checkHave() {
dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
}
} 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));
}
}

20
src/DefaultBtProgressInfoFile.cc
View File

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

25
src/DefaultBtRequestFactory.cc
View File

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

4
src/DefaultBtRequestFactory.h
View File

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

130
src/DefaultPieceStorage.cc
View File

@ -86,24 +86,19 @@ bool DefaultPieceStorage::isEndGame()
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()) {
index = bitfieldMan->getMissingIndex(peer->getBitfield(),
peer->getBitfieldLength());
return bitfieldMan->getMissingIndex(index, peer->getBitfield(),
peer->getBitfieldLength());
} else {
index = bitfieldMan->getMissingUnusedIndex(peer->getBitfield(),
peer->getBitfieldLength());
return bitfieldMan->getMissingUnusedIndex(index, peer->getBitfield(),
peer->getBitfieldLength());
}
return index;
}
PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index)
PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
{
if(index == -1) {
return 0;
}
bitfieldMan->setUseBit(index);
PieceHandle piece = findUsedPiece(index);
@ -120,7 +115,7 @@ PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index)
* Newly instantiated piece is not added to usedPieces.
* 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()) {
PieceHandle piece = findUsedPiece(index);
@ -143,16 +138,16 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
class FindPiece {
private:
int32_t index;
size_t index;
public:
FindPiece(int32_t index):index(index) {}
FindPiece(size_t index):index(index) {}
bool operator()(const PieceHandle& piece) {
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(),
usedPieces.end(),
@ -166,13 +161,17 @@ PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const
PieceHandle DefaultPieceStorage::getMissingPiece(const PeerHandle& peer)
{
int32_t index = getMissingPieceIndex(peer);
return checkOutPiece(index);
size_t 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) {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength());
@ -183,28 +182,38 @@ int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer)
}
}
if(isEndGame()) {
index = bitfieldMan->getMissingIndex(tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength());
return bitfieldMan->getMissingIndex(index, tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength());
} else {
index = bitfieldMan->getMissingUnusedIndex(tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength());
return bitfieldMan->getMissingUnusedIndex(index,
tempBitfield.getBitfield(),
tempBitfield.getBitfieldLength());
}
}
return index;
return false;
}
PieceHandle DefaultPieceStorage::getMissingFastPiece(const PeerHandle& peer)
{
int32_t index = getMissingFastPieceIndex(peer);
return checkOutPiece(index);
size_t index;
if(getMissingFastPieceIndex(index, peer)) {
return checkOutPiece(index);
} else {
return 0;
}
}
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)) {
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(toDelete <= 0) {
if(usedPieces.size() <= delMax) {
return;
}
int32_t fillRate = 10;
size_t toDelete = usedPieces.size()-delMax;
int fillRate = 10;
while(fillRate < 50) {
int32_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete);
size_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete);
if(deleted == 0) {
break;
}
@ -241,10 +250,10 @@ void DefaultPieceStorage::reduceUsedPieces(int32_t delMax)
}
}
int32_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int32_t fillRate,
int32_t toDelete)
size_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int fillRate,
size_t toDelete)
{
int32_t deleted = 0;
size_t deleted = 0;
for(Pieces::iterator itr = usedPieces.begin();
itr != usedPieces.end() && deleted < toDelete;) {
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);
}
bool DefaultPieceStorage::isPieceUsed(int32_t index)
bool DefaultPieceStorage::isPieceUsed(size_t index)
{
return bitfieldMan->isUseBitSet(index);
}
int64_t DefaultPieceStorage::getTotalLength()
uint64_t DefaultPieceStorage::getTotalLength()
{
return bitfieldMan->getTotalLength();
}
int64_t DefaultPieceStorage::getFilteredTotalLength()
uint64_t DefaultPieceStorage::getFilteredTotalLength()
{
return bitfieldMan->getFilteredTotalLength();
}
int64_t DefaultPieceStorage::getCompletedLength()
uint64_t DefaultPieceStorage::getCompletedLength()
{
return bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength();
}
int64_t DefaultPieceStorage::getFilteredCompletedLength()
uint64_t DefaultPieceStorage::getFilteredCompletedLength()
{
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
@ -444,12 +453,12 @@ void DefaultPieceStorage::initStorage()
}
void DefaultPieceStorage::setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength)
size_t bitfieldLength)
{
bitfieldMan->setBitfield(bitfield, bitfieldLength);
}
int32_t DefaultPieceStorage::getBitfieldLength()
size_t DefaultPieceStorage::getBitfieldLength()
{
return bitfieldMan->getBitfieldLength();
}
@ -463,21 +472,22 @@ DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() {
return diskAdaptor;
}
int32_t DefaultPieceStorage::getPieceLength(int32_t index)
size_t DefaultPieceStorage::getPieceLength(size_t 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);
haves.push_front(entry);
}
std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
const Time& lastCheckTime)
std::deque<size_t>
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++) {
const Haves::value_type& have = *itr;
if(have.getCuid() == myCuid) {
@ -494,9 +504,9 @@ std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCui
class FindElapsedHave
{
private:
int32_t elapsed;
time_t elapsed;
public:
FindElapsedHave(int32_t elapsed):elapsed(elapsed) {}
FindElapsedHave(time_t elapsed):elapsed(elapsed) {}
bool operator()(const HaveEntry& have) {
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 =
std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
@ -522,19 +532,19 @@ void DefaultPieceStorage::markAllPiecesDone()
bitfieldMan->setAllBit();
}
void DefaultPieceStorage::markPiecesDone(int64_t length)
void DefaultPieceStorage::markPiecesDone(uint64_t length)
{
if(length == bitfieldMan->getTotalLength()) {
bitfieldMan->setAllBit();
} else {
int32_t numPiece = length/bitfieldMan->getBlockLength();
size_t numPiece = length/bitfieldMan->getBlockLength();
if(numPiece > 0) {
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) {
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);
}
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);
}
@ -552,7 +562,7 @@ void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
std::copy(pieces.begin(), pieces.end(), std::back_inserter(usedPieces));
}
int32_t DefaultPieceStorage::countInFlightPiece()
size_t DefaultPieceStorage::countInFlightPiece()
{
return usedPieces.size();
}

62
src/DefaultPieceStorage.h
View File

@ -51,10 +51,10 @@ class FileEntry;
class HaveEntry {
private:
int32_t cuid;
int32_t index;
size_t index;
Time registeredTime;
public:
HaveEntry(int32_t cuid, int32_t index):
HaveEntry(int32_t cuid, size_t index):
cuid(cuid),
index(index) {}
@ -74,20 +74,20 @@ private:
SharedHandle<DiskAdaptor> diskAdaptor;
SharedHandle<DiskWriterFactory> _diskWriterFactory;
std::deque<SharedHandle<Piece> > usedPieces;
int32_t endGamePieceNum;
size_t endGamePieceNum;
Logger* logger;
const Option* option;
Haves haves;
int32_t getMissingPieceIndex(const SharedHandle<Peer>& peer);
int32_t getMissingFastPieceIndex(const SharedHandle<Peer>& peer);
SharedHandle<Piece> checkOutPiece(int32_t index);
int32_t deleteUsedPiecesByFillRate(int32_t fillRate, int32_t toDelete);
void reduceUsedPieces(int32_t delMax);
bool getMissingPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
bool getMissingFastPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
SharedHandle<Piece> checkOutPiece(size_t index);
size_t deleteUsedPiecesByFillRate(int fillRate, size_t toDelete);
void reduceUsedPieces(size_t delMax);
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:
DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option);
@ -101,25 +101,25 @@ public:
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 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();
@ -134,17 +134,17 @@ public:
virtual bool allDownloadFinished();
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();
void setEndGamePieceNum(int32_t num) {
void setEndGamePieceNum(size_t num) {
endGamePieceNum = num;
}
int32_t getEndGamePieceNum() const {
size_t getEndGamePieceNum() const {
return endGamePieceNum;
}
@ -156,24 +156,24 @@ public:
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,
const Time& lastCheckTime);
virtual std::deque<size_t>
getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime);
virtual void removeAdvertisedPiece(int32_t elapsed);
virtual void removeAdvertisedPiece(time_t elapsed);
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 int32_t countInFlightPiece();
virtual size_t countInFlightPiece();
virtual std::deque<SharedHandle<Piece> > getInFlightPieces();

2
src/DownloadCommand.cc
View File

@ -109,7 +109,7 @@ bool DownloadCommand::executeInternal() {
setReadCheckSocket(socket);
SegmentHandle segment = _segments.front();
int32_t BUFSIZE = 16*1024;
size_t BUFSIZE = 16*1024;
unsigned char buf[BUFSIZE];
int32_t 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() {}
void GrowSegment::updateWrittenLength(int32_t bytes)
void GrowSegment::updateWrittenLength(size_t bytes)
{
_writtenLength += bytes;
_piece->reconfigure(_writtenLength);

18
src/GrowSegment.h
View File

@ -42,7 +42,7 @@ namespace aria2 {
class GrowSegment:public Segment {
private:
SharedHandle<Piece> _piece;
int32_t _writtenLength;
size_t _writtenLength;
public:
GrowSegment(const SharedHandle<Piece>& piece);
@ -53,42 +53,42 @@ public:
return false;
}
virtual int32_t getIndex() const
virtual size_t getIndex() const
{
return 0;
}
virtual int64_t getPosition() const
virtual off_t getPosition() const
{
return 0;
}
virtual int64_t getPositionToWrite() const
virtual off_t getPositionToWrite() const
{
return _writtenLength;
}
virtual int32_t getLength() const
virtual size_t getLength() const
{
return 0;
}
virtual int32_t getSegmentLength() const
virtual size_t getSegmentLength() const
{
return 0;
}
virtual int32_t getWrittenLength() const
virtual size_t getWrittenLength() const
{
return _writtenLength;
}
virtual int32_t getOverflowLength() const
virtual size_t getOverflowLength() const
{
return 0;
}
virtual void updateWrittenLength(int32_t bytes);
virtual void updateWrittenLength(size_t bytes);
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(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 =
BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
}
@ -82,7 +82,7 @@ bool Piece::operator==(const Piece& piece) const
return index == piece.index;
}
void Piece::completeBlock(int32_t blockIndex) {
void Piece::completeBlock(size_t blockIndex) {
bitfield->setBit(blockIndex);
bitfield->unsetUseBit(blockIndex);
}
@ -100,17 +100,17 @@ bool Piece::pieceComplete() const {
return bitfield->isAllBitSet();
}
int32_t Piece::countBlock() const
size_t Piece::countBlock() const
{
return bitfield->countBlock();
}
int32_t Piece::getBlockLength(int32_t index) const
size_t Piece::getBlockLength(size_t index) const
{
return bitfield->getBlockLength(index);
}
int32_t Piece::getBlockLength() const
size_t Piece::getBlockLength() const
{
return bitfield->getBlockLength();
}
@ -120,54 +120,56 @@ const unsigned char* Piece::getBitfield() const
return bitfield->getBitfield();
}
int32_t Piece::getBitfieldLength() const
size_t Piece::getBitfieldLength() const
{
return bitfield->getBitfieldLength();
}
bool Piece::isBlockUsed(int32_t index) const
bool Piece::isBlockUsed(size_t index) const
{
return bitfield->isUseBitSet(index);
}
void Piece::cancelBlock(int32_t blockIndex) {
void Piece::cancelBlock(size_t blockIndex) {
bitfield->unsetUseBit(blockIndex);
}
int32_t Piece::countCompleteBlock() const
size_t Piece::countCompleteBlock() const
{
return bitfield->countBlock()-bitfield->countMissingBlock();
}
bool Piece::hasBlock(int32_t blockIndex) const
bool Piece::hasBlock(size_t blockIndex) const
{
return bitfield->isBitSet(blockIndex);
}
int32_t Piece::getMissingUnusedBlockIndex() 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
bool Piece::getMissingUnusedBlockIndex(size_t& index) 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();
}
@ -175,7 +177,7 @@ std::string Piece::toString() const {
return "piece: index="+Util::itos(index)+", length="+Util::itos(length);
}
void Piece::reconfigure(int32_t length)
void Piece::reconfigure(size_t length)
{
delete bitfield;
this->length = length;
@ -183,12 +185,12 @@ void Piece::reconfigure(int32_t 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);
}
int32_t Piece::getCompletedLength()
size_t Piece::getCompletedLength()
{
return bitfield->getCompletedLength();
}

50
src/Piece.h
View File

@ -47,17 +47,17 @@ class BitfieldMan;
class Piece {
private:
int32_t index;
int32_t length;
int32_t _blockLength;
size_t index;
size_t length;
size_t _blockLength;
BitfieldMan* bitfield;
public:
static const int32_t BLOCK_LENGTH = 16*1024;
static const size_t BLOCK_LENGTH = 16*1024;
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);
@ -67,16 +67,16 @@ public:
bool operator==(const Piece& piece) const;
int32_t getMissingUnusedBlockIndex() const;
int32_t getMissingBlockIndex() const;
int32_t getFirstMissingBlockIndexWithoutLock() const;
std::deque<int32_t> getAllMissingBlockIndexes() const;
void completeBlock(int32_t blockIndex);
void cancelBlock(int32_t blockIndex);
bool getMissingUnusedBlockIndex(size_t& index) const;
bool getMissingBlockIndex(size_t& index) const;
bool getFirstMissingBlockIndexWithoutLock(size_t& index) const;
std::deque<size_t> getAllMissingBlockIndexes() const;
void completeBlock(size_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
@ -84,40 +84,40 @@ public:
*/
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;
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 setAllBlock();
std::string toString() const;
bool isBlockUsed(int32_t index) const;
bool isBlockUsed(size_t index) const;
// Calculates completed length
int32_t getCompletedLength();
size_t getCompletedLength();
/**
* Loses current bitfield state.
*/
void reconfigure(int32_t length);
void reconfigure(size_t length);
};
typedef SharedHandle<Piece> PieceHandle;

34
src/PieceStorage.h
View File

@ -88,18 +88,18 @@ public:
* then returns 0.
* 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.
* 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.
*/
virtual void markPieceMissing(int32_t index) = 0;
virtual void markPieceMissing(size_t index) = 0;
/**
* Tells that the download of the specfied piece completes.
@ -115,17 +115,17 @@ public:
* Returns true if the specified piece is already downloaded.
* 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;
@ -155,9 +155,9 @@ public:
virtual const unsigned char* getBitfield() = 0;
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;
@ -167,26 +167,26 @@ public:
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
* 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
* newer than lastCheckTime.
*/
virtual std::deque<int32_t>
virtual std::deque<size_t>
getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0;
/**
* Removes have entry if specified seconds have elapsed since its
* registration.
*/
virtual void removeAdvertisedPiece(int32_t elapsed) = 0;
virtual void removeAdvertisedPiece(time_t elapsed) = 0;
/**
* Sets all bits in bitfield to 1.
@ -196,12 +196,12 @@ public:
/**
* 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
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;
};

28
src/PiecedSegment.cc
View File

@ -34,12 +34,18 @@
/* copyright --> */
#include "PiecedSegment.h"
#include "Piece.h"
#include <cassert>
namespace aria2 {
PiecedSegment::PiecedSegment(int32_t pieceLength, const PieceHandle& piece):
_pieceLength(pieceLength), _overflowLength(0), _piece(piece),
_writtenLength(_piece->getFirstMissingBlockIndexWithoutLock()*_piece->getBlockLength()) {}
PiecedSegment::PiecedSegment(size_t pieceLength, const PieceHandle& piece):
_pieceLength(pieceLength), _overflowLength(0), _piece(piece)
{
size_t index;
bool t = _piece->getFirstMissingBlockIndexWithoutLock(index);
assert(t);
_writtenLength = index*_piece->getBlockLength();
}
PiecedSegment::~PiecedSegment() {}
@ -48,34 +54,34 @@ bool PiecedSegment::complete() const
return _piece->pieceComplete();
}
int32_t PiecedSegment::getIndex() const
size_t PiecedSegment::getIndex() const
{
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;
}
int32_t PiecedSegment::getLength() const
size_t PiecedSegment::getLength() const
{
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()) {
_overflowLength = 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);
}
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.
* The last piece likely have shorter length than the other length.
*/
int32_t _pieceLength;
int32_t _overflowLength;
size_t _pieceLength;
size_t _overflowLength;
SharedHandle<Piece> _piece;
int32_t _writtenLength;
size_t _writtenLength;
public:
PiecedSegment(int32_t pieceLength, const SharedHandle<Piece>& piece);
PiecedSegment(size_t pieceLength, const SharedHandle<Piece>& piece);
virtual ~PiecedSegment();
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;
}
virtual int32_t getWrittenLength() const
virtual size_t getWrittenLength() const
{
return _writtenLength;
}
virtual int32_t getOverflowLength() const
virtual size_t getOverflowLength() const
{
return _overflowLength;
}
virtual void updateWrittenLength(int32_t bytes);
virtual void updateWrittenLength(size_t bytes);
virtual void clear();

16
src/Segment.h
View File

@ -50,21 +50,21 @@ public:
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;

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) {
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(_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) {
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()) {
return true;
@ -145,7 +145,7 @@ DiskAdaptorHandle UnknownLengthPieceStorage::getDiskAdaptor()
return _diskAdaptor;
}
int32_t UnknownLengthPieceStorage::getPieceLength(int32_t index)
size_t UnknownLengthPieceStorage::getPieceLength(size_t index)
{
if(index == 0) {
return _totalLength;

38
src/UnknownLengthPieceStorage.h
View File

@ -54,7 +54,7 @@ private:
SharedHandle<DiskWriterFactory> _diskWriterFactory;
int64_t _totalLength;
uint64_t _totalLength;
bool _downloadFinished;
@ -106,13 +106,13 @@ public:
* then returns 0.
* 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.
* 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.
@ -128,27 +128,27 @@ public:
* Returns true if the specified piece is already downloaded.
* 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;
}
virtual int64_t getFilteredTotalLength()
virtual uint64_t getFilteredTotalLength()
{
return _totalLength;
}
virtual int64_t getCompletedLength()
virtual uint64_t getCompletedLength()
{
// TODO we have to return actual completed length here?
return _totalLength;
}
virtual int64_t getFilteredCompletedLength()
virtual uint64_t getFilteredCompletedLength()
{
return getCompletedLength();
}
@ -190,9 +190,9 @@ public:
}
virtual void setBitfield(const unsigned char* bitfield,
int32_t bitfieldLength) {}
size_t bitfieldLength) {}
virtual int32_t getBitfieldLength()
virtual size_t getBitfieldLength()
{
return 0;
}
@ -211,42 +211,42 @@ public:
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
* 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
* newer than lastCheckTime.
*/
virtual std::deque<int32_t>
virtual std::deque<size_t>
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
* registration.
*/
virtual void removeAdvertisedPiece(int32_t elapsed) {}
virtual void removeAdvertisedPiece(time_t elapsed) {}
/**
* Sets all bits in bitfield to 1.
*/
virtual void markAllPiecesDone();
virtual void markPiecesDone(int64_t length)
virtual void markPiecesDone(uint64_t length)
{
// TODO not implemented yet
abort();
}
virtual void markPieceMissing(int32_t index)
virtual void markPieceMissing(size_t index)
{
// TODO not implemented yet
abort();
@ -258,7 +258,7 @@ public:
*/
virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {}
virtual int32_t countInFlightPiece()
virtual size_t countInFlightPiece()
{
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)
{
for(int32_t index = 0; index < dest->countBlock(); ++index) {
if(src->isBitSetOffsetRange((int64_t)index*dest->getBlockLength(),
size_t numBlock = dest->countBlock();
for(size_t index = 0; index < numBlock; ++index) {
if(src->isBitSetOffsetRange((uint64_t)index*dest->getBlockLength(),
dest->getBlockLength())) {
dest->setBit(index);
}

457
test/BitfieldManTest.cc
View File

@ -63,38 +63,64 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BitfieldManTest );
void BitfieldManTest::testGetBlockSize() {
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);
CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt2.getBlockLength(9));
CPPUNIT_ASSERT_EQUAL((int32_t)1, bt2.getBlockLength(10));
CPPUNIT_ASSERT_EQUAL((int32_t)0, bt2.getBlockLength(11));
CPPUNIT_ASSERT_EQUAL((size_t)1024, bt2.getBlockLength(9));
CPPUNIT_ASSERT_EQUAL((size_t)1, bt2.getBlockLength(10));
CPPUNIT_ASSERT_EQUAL((size_t)0, bt2.getBlockLength(11));
}
void BitfieldManTest::testGetFirstMissingUnusedIndex()
{
{
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);
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.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();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingUnusedIndex());
{
size_t index;
CPPUNIT_ASSERT(!bt1.getFirstMissingUnusedIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
bt1.addFilter(1024, 1024*10);
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);
CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingUnusedIndex());
{
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
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);
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
{
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
}
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.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();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingIndex());
{
size_t index;
CPPUNIT_ASSERT(!bt1.getFirstMissingIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
bt1.addFilter(1024, 1024*10);
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);
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
{
size_t index;
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
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);
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);
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.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();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex());
{
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
@ -146,11 +212,23 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
bt1.addFilter(1024, 1024*10);
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);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex());
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
}
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);
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);
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.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();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingIndex());
{
size_t index;
CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
}
}
{
BitfieldMan bt1(1024, 1024*10);
@ -175,11 +267,23 @@ void BitfieldManTest::testGetMissingIndex_noarg()
bt1.addFilter(1024, 1024*10);
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);
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
{
size_t index;
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
}
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);
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.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.isAllBitSet());
@ -213,29 +317,27 @@ void BitfieldManTest::testFilter() {
unsigned char peerBt[2];
memset(peerBt, 0xff, sizeof(peerBt));
int index;
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
size_t index;
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(2, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(3, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(4, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(5, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(6, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(7, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(-1, index);
CPPUNIT_ASSERT_EQUAL((int64_t)12, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
CPPUNIT_ASSERT_EQUAL(12ULL, btman.getFilteredTotalLength());
// test offset=5, length=2
btman.clearAllBit();
@ -243,24 +345,22 @@ void BitfieldManTest::testFilter() {
btman.clearFilter();
btman.addFilter(5, 2);
btman.enableFilter();
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
btman.setBit(index);
CPPUNIT_ASSERT_EQUAL(2, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
btman.setUseBit(index);
btman.setBit(index);
CPPUNIT_ASSERT_EQUAL(3, index);
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
btman.setUseBit(index);
CPPUNIT_ASSERT_EQUAL(-1, index);
CPPUNIT_ASSERT_EQUAL((int64_t)4, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
CPPUNIT_ASSERT_EQUAL(4ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
BitfieldMan btman2(2, 31);
btman2.addFilter(0, 31);
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,
};
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.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();
unsigned char bitArray2[] = {
@ -296,7 +399,8 @@ void BitfieldManTest::testGetMissingIndex() {
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[] = {
0x00, 0xff, 0xff, 0xff,
@ -309,7 +413,8 @@ void BitfieldManTest::testGetMissingIndex() {
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[] = {
0x00, 0x00, 0x00, 0x00,
@ -322,71 +427,91 @@ void BitfieldManTest::testGetMissingIndex() {
0x00, 0x00, 0x00, 0x00,
};
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bt1.getMissingIndex(bitArray4, 32));
CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
}
void BitfieldManTest::testGetSparceMissingUnusedIndex() {
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);
CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)9, index);
bitfield.setUseBit(9);
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
}
void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() {
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.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);
CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
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);
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
}
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;
BitfieldMan bitfield(pieceLength, totalLength);
bitfield.setAllBit();
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, -1));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100));
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100));
@ -412,91 +537,91 @@ void BitfieldManTest::testIsBitSetOffsetRange()
void BitfieldManTest::testGetMissingUnusedLength()
{
int64_t totalLength = 1024*10+10;
int32_t blockLength = 1024;
uint64_t totalLength = 1024*10+10;
size_t blockLength = 1024;
BitfieldMan bf(blockLength, totalLength);
// 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.
CPPUNIT_ASSERT_EQUAL((int64_t)10, bf.getMissingUnusedLength(10));
CPPUNIT_ASSERT_EQUAL(10ULL, bf.getMissingUnusedLength(10));
// from index -1
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(-1));
CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(-1));
// from index 11
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(11));
CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(11));
// 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.
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.
bf.setBit(4);
CPPUNIT_ASSERT_EQUAL((int64_t)4*blockLength, bf.getMissingUnusedLength(0));
CPPUNIT_ASSERT_EQUAL(4ULL*blockLength, bf.getMissingUnusedLength(0));
// from index 1
CPPUNIT_ASSERT_EQUAL((int64_t)3*blockLength, bf.getMissingUnusedLength(1));
CPPUNIT_ASSERT_EQUAL(3ULL*blockLength, bf.getMissingUnusedLength(1));
}
void BitfieldManTest::testSetBitRange()
{
int32_t blockLength = 1024*1024;
int64_t totalLength = 10*blockLength;
size_t blockLength = 1024*1024;
uint64_t totalLength = 10*blockLength;
BitfieldMan bf(blockLength, totalLength);
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));
}
for(int32_t i = 5; i < 10; ++i) {
for(size_t i = 5; i < 10; ++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()
{
int32_t blockLength = 16*1024;
int64_t totalLength = 1024*1024;
size_t blockLength = 16*1024;
uint64_t totalLength = 1024*1024;
BitfieldMan bf(blockLength, totalLength);
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);
}
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()
{
int32_t blockLength = 16*1024;
int64_t totalLength = 1024*1024;
size_t blockLength = 16*1024;
uint64_t totalLength = 1024*1024;
BitfieldMan bf(blockLength, totalLength);
BitfieldMan peerBf(blockLength, totalLength);
peerBf.setAllBit();
CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(),
peerBf.getBitfieldLength()).size());
for(int32_t i = 0; i < 62; ++i) {
for(size_t i = 0; i < 62; ++i) {
bf.setBit(i);
}
peerBf.unsetBit(62);
{
std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
peerBf.getBitfieldLength());
std::deque<size_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
peerBf.getBitfieldLength());
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);
bt1.setRandomizer(fixedNumberRandomizer);
unsigned char bitArray[] = {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex(bitArray, 32));
size_t index;
{
unsigned char bitArray[] = {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
};
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
bt1.addFilter(1024, 1024*256);
bt1.enableFilter();
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.setUseBit(1);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.disableFilter();
bt1.addFilter(1024, 1024*256);
bt1.enableFilter();
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
bt1.setUseBit(1);
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bt1.disableFilter();
bt1.setBit(0);
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.setBit(0);
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
bt1.setAllBit();
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
bt1.setAllBit();
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,
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_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray4, 32));
bt1.clearAllBit();
bt1.setAllUseBit();
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
}
{
unsigned char bitArray4[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray4, 32));
}
}
void BitfieldManTest::testCountFilteredBlock()
{
BitfieldMan bt(1024, 1024*256);
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
bt.addFilter(1024, 1024*256);
bt.enableFilter();
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(255, bt.countFilteredBlock());
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL((size_t)255, bt.countFilteredBlock());
bt.disableFilter();
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
}
} // namespace aria2

2
test/BtRequestMessageTest.cc
View File

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

10
test/DefaultBtMessageDispatcherTest.cc
View File

@ -111,7 +111,7 @@ public:
private:
SharedHandle<Piece> piece;
public:
virtual SharedHandle<Piece> getPiece(int index) {
virtual SharedHandle<Piece> getPiece(size_t index) {
return piece;
}
@ -281,7 +281,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
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();
pieceStorage->setPiece(piece);
@ -308,7 +310,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
slot.setDispatchedTime(0);
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();
pieceStorage->setPiece(piece);

116
test/DefaultBtProgressInfoFileTest.cc
View File

@ -110,22 +110,22 @@ void DefaultBtProgressInfoFileTest::testLoad()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)2,
CPPUNIT_ASSERT_EQUAL((size_t)2,
_pieceStorage->countInFlightPiece());
// piece index 1
std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
SharedHandle<Piece> piece1 = inFlightPieces[0];
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
piece1->getBitfieldLength()));
// piece index 2
SharedHandle<Piece> piece2 = inFlightPieces[1];
CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
}
void DefaultBtProgressInfoFileTest::testLoad_nonBt()
@ -146,22 +146,22 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)2,
CPPUNIT_ASSERT_EQUAL((size_t)2,
_pieceStorage->countInFlightPiece());
// piece index 1
std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
SharedHandle<Piece> piece1 = inFlightPieces[0];
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
piece1->getBitfieldLength()));
// piece index 2
SharedHandle<Piece> piece2 = inFlightPieces[1];
CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
}
@ -184,7 +184,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
// the number of in-flight pieces
CPPUNIT_ASSERT_EQUAL((int32_t)0,
CPPUNIT_ASSERT_EQUAL((size_t)0,
_pieceStorage->countInFlightPiece());
}
@ -224,47 +224,47 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
in.read((char*)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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength);
int64_t totalLength;
CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
uint64_t 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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
unsigned char bitfieldRead[10];
in.read((char*)bitfieldRead, sizeof(bitfieldRead));
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
int32_t numInFlightPiece;
uint32_t numInFlightPiece;
in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
// piece index 1
int32_t index1;
uint32_t 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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
unsigned char pieceBitfield1[1];
in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@ -272,13 +272,13 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
// piece index 2
int32_t index2;
uint32_t 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));
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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)20, infoHashLength);
CPPUNIT_ASSERT_EQUAL((uint32_t)20, infoHashLength);
unsigned char infoHashRead[20];
in.read((char*)infoHashRead, sizeof(infoHashRead));
CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"),
Util::toHex(infoHashRead, sizeof(infoHashRead)));
int32_t pieceLength;
uint32_t 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));
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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
unsigned char bitfieldRead[10];
in.read((char*)bitfieldRead, sizeof(bitfieldRead));
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
int32_t numInFlightPiece;
uint32_t numInFlightPiece;
in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
// piece index 1
int32_t index1;
uint32_t 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));
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));
CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
unsigned char pieceBitfield1[1];
in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@ -374,13 +374,13 @@ void DefaultBtProgressInfoFileTest::testSave()
Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
// piece index 2
int32_t index2;
uint32_t 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));
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 {
public:
int index;
int blockIndex;
size_t index;
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;
@ -126,7 +126,7 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
CPPUNIT_ASSERT_EQUAL((int32_t)2, btRequestFactory->countTargetPiece());
btRequestFactory->removeCompletedPiece();
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() {
@ -141,16 +141,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
++itr;
msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
++itr;
msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
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());
std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(0, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
++itr;
msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index);
CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
++itr;
msg = (MockBtRequestMessage*)itr->get();
CPPUNIT_ASSERT_EQUAL(1, msg->index);
CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
}
void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {

42
test/DefaultPieceStorageTest.cc
View File

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

6
test/GrowSegmentTest.cc
View File

@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
GrowSegment segment(new Piece());
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.getPiece()->pieceComplete());
}
@ -36,9 +36,9 @@ void GrowSegmentTest::testClear()
{
GrowSegment segment(new Piece());
segment.updateWrittenLength(32*1024);
CPPUNIT_ASSERT_EQUAL((int32_t)32*1024, segment.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((size_t)32*1024, segment.getWrittenLength());
segment.clear();
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, segment.getWrittenLength());
}
} // namespace aria2

4
test/MockBtRequestFactory.h
View File

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

58
test/MockPieceStorage.h
View File

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

2
test/PieceTest.cc
View File

@ -42,7 +42,7 @@ void PieceTest::testGetCompletedLength()
p.completeBlock(9);
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

16
test/SegmentManTest.cc
View File

@ -43,10 +43,10 @@ void SegmentManTest::testNullBitfield()
SharedHandle<Segment> segment = segmentMan.getSegment(1);
CPPUNIT_ASSERT(!segment.isNull());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getIndex());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getSegmentLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getWrittenLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getSegmentLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getWrittenLength());
SharedHandle<Segment> segment2 = segmentMan.getSegment(2);
CPPUNIT_ASSERT(segment2.isNull());
@ -58,8 +58,8 @@ void SegmentManTest::testNullBitfield()
void SegmentManTest::testCompleteSegment()
{
Option op;
int32_t pieceLength = 1024*1024;
int64_t totalLength = 64*1024*1024;
size_t pieceLength = 1024*1024;
uint64_t totalLength = 64*1024*1024;
SharedHandle<MockBtContext> dctx = new MockBtContext();
dctx->setPieceLength(pieceLength);
dctx->setTotalLength(totalLength);
@ -78,8 +78,8 @@ void SegmentManTest::testCompleteSegment()
std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1);
CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
CPPUNIT_ASSERT_EQUAL(0, segments[0]->getIndex());
CPPUNIT_ASSERT_EQUAL(2, segments[1]->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
CPPUNIT_ASSERT_EQUAL((size_t)2, segments[1]->getIndex());
}
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);
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);
CPPUNIT_ASSERT(p->hasBlock(0));
@ -49,7 +49,7 @@ void SegmentTest::testUpdateWrittenLength_overflow()
s.updateWrittenLength(16*1024*11);
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()
@ -77,11 +77,11 @@ void SegmentTest::testClear()
SharedHandle<Piece> p = new Piece(0, 16*1024*10);
PiecedSegment s(16*1024*10, p);
s.updateWrittenLength(16*1024*11);
CPPUNIT_ASSERT_EQUAL((int32_t)16*1024*10, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength());
CPPUNIT_ASSERT_EQUAL((size_t)16*1024*10, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
s.clear();
CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getOverflowLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
CPPUNIT_ASSERT_EQUAL((size_t)0, s.getOverflowLength());
}
} // namespace aria2