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

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

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;
}

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;
};

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;

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));
}
}

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);

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));

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();

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();
}

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();

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) {

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);

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();

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();
}

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;

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;
};

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()) {

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();

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;

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;

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;
}

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);
}

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

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;
}
};

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);

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);
}

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() {

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));
}
}

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

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

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();
}

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

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()

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