diff options
| author | Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com> | 2008-03-08 08:04:28 +0000 |
|---|---|---|
| committer | Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com> | 2008-03-08 08:04:28 +0000 |
| commit | 518a200d57509016cfb886df01912a8f4cdadbc0 (patch) | |
| tree | 98dc56246a1d75ea9ca4eb72ea631299b2b7f919 | |
| parent | aa669e8646d5cb89d1e4aaba45b66b64932153ed (diff) | |
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
34 files changed, 970 insertions, 776 deletions
@@ -1,5 +1,44 @@ 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 It seems that defining gettext(Msgid) to ((const char *) (Msgid)) in gettext.h causes the problem. diff --git a/src/BitfieldMan.cc b/src/BitfieldMan.cc index aadc6025..cb364643 100644 --- a/src/BitfieldMan.cc +++ b/src/BitfieldMan.cc @@ -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; - } - currentRange.endIndex = getEndIndex(currentRange.startIndex); - if(maxRange < currentRange) { - maxRange = currentRange; + { + 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; } - 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; } diff --git a/src/BitfieldMan.h b/src/BitfieldMan.h index b4509354..ed0401c6 100644 --- a/src/BitfieldMan.h +++ b/src/BitfieldMan.h @@ -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; }; diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h index 2d1f8c87..89f5c3f3 100644 --- a/src/BtRequestFactory.h +++ b/src/BtRequestFactory.h @@ -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; diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc index 51309b2d..fa0a5992 100644 --- a/src/DefaultBtInteractive.cc +++ b/src/DefaultBtInteractive.cc @@ -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)); } } diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc index 0c11f33b..7fc1291b 100644 --- a/src/DefaultBtProgressInfoFile.cc +++ b/src/DefaultBtProgressInfoFile.cc @@ -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); diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc index 55d14bf5..34c49c50 100644 --- a/src/DefaultBtRequestFactory.cc +++ b/src/DefaultBtRequestFactory.cc @@ -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)); diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h index f71f0627..665237ff 100644 --- a/src/DefaultBtRequestFactory.h +++ b/src/DefaultBtRequestFactory.h @@ -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(); diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc index 28884d2f..4752ed00 100644 --- a/src/DefaultPieceStorage.cc +++ b/src/DefaultPieceStorage.cc @@ -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(); } diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h index 0d354c74..31d0981f 100644 --- a/src/DefaultPieceStorage.h +++ b/src/DefaultPieceStorage.h @@ -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(); diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc index 5e5a3a05..4a9f8d23 100644 --- a/src/DownloadCommand.cc +++ b/src/DownloadCommand.cc @@ -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) { diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc index abeb55bb..0fbd9e88 100644 --- a/src/GrowSegment.cc +++ b/src/GrowSegment.cc @@ -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); diff --git a/src/GrowSegment.h b/src/GrowSegment.h index 8c01ccf6..697d88d9 100644 --- a/src/GrowSegment.h +++ b/src/GrowSegment.h @@ -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(); diff --git a/src/Piece.cc b/src/Piece.cc index dcb28d8f..aa56401e 100644 --- a/src/Piece.cc +++ b/src/Piece.cc @@ -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; +bool Piece::getMissingUnusedBlockIndex(size_t& index) const +{ + if(bitfield->getFirstMissingUnusedIndex(index)) { + bitfield->setUseBit(index); + return true; + } else { + return false; } - bitfield->setUseBit(blockIndex); - return blockIndex; } -int32_t Piece::getMissingBlockIndex() const { - int32_t blockIndex = bitfield->getMissingIndex(); - if(blockIndex == -1) { - return blockIndex; +bool Piece::getMissingBlockIndex(size_t& index) const +{ + if(bitfield->getMissingIndex(index)) { + bitfield->setUseBit(index); + return true; + } else { + return false; } - bitfield->setUseBit(blockIndex); - return blockIndex; } -int32_t Piece::getFirstMissingBlockIndexWithoutLock() const +bool Piece::getFirstMissingBlockIndexWithoutLock(size_t& index) const { - return bitfield->getFirstMissingIndex(); + return bitfield->getFirstMissingIndex(index); } -std::deque<int32_t> Piece::getAllMissingBlockIndexes() const { +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(); } diff --git a/src/Piece.h b/src/Piece.h index 8c21f948..67e61f43 100644 --- a/src/Piece.h +++ b/src/Piece.h @@ -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; diff --git a/src/PieceStorage.h b/src/PieceStorage.h index 2ed354f8..341371b7 100644 --- a/src/PieceStorage.h +++ b/src/PieceStorage.h @@ -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; }; diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc index e6932437..1570c1bd 100644 --- a/src/PiecedSegment.cc +++ b/src/PiecedSegment.cc @@ -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()) { diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h index 73217a23..87b415c4 100644 --- a/src/PiecedSegment.h +++ b/src/PiecedSegment.h @@ -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(); diff --git a/src/Segment.h b/src/Segment.h index acf0d9c2..c7499fbb 100644 --- a/src/Segment.h +++ b/src/Segment.h @@ -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; diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc index d972aea6..3c35eeb7 100644 --- a/src/UnknownLengthPieceStorage.cc +++ b/src/UnknownLengthPieceStorage.cc @@ -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; diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h index f548cedf..a1e61c3a 100644 --- a/src/UnknownLengthPieceStorage.h +++ b/src/UnknownLengthPieceStorage.h @@ -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; } diff --git a/src/Util.cc b/src/Util.cc index 71b69ae1..0d9b0429 100644 --- a/src/Util.cc +++ b/src/Util.cc @@ -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); } diff --git a/test/BitfieldManTest.cc b/test/BitfieldManTest.cc index 68ca78d1..3012b1e0 100644 --- a/test/BitfieldManTest.cc +++ b/test/BitfieldManTest.cc @@ -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)); - btman.setUseBit(index); - CPPUNIT_ASSERT_EQUAL(2, index); - index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt)); + size_t 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)2, 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)3, 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)4, 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)5, index); + CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt))); btman.setUseBit(index); - CPPUNIT_ASSERT_EQUAL(7, 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(-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 diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc index 349f42cc..9b1cc8be 100644 --- a/test/BtRequestMessageTest.cc +++ b/test/BtRequestMessageTest.cc @@ -54,7 +54,7 @@ public: class MockPieceStorage2 : public MockPieceStorage { public: - virtual bool hasPiece(int index) { + virtual bool hasPiece(size_t index) { return index == 1; } }; diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc index 707ee718..97504f57 100644 --- a/test/DefaultBtMessageDispatcherTest.cc +++ b/test/DefaultBtMessageDispatcherTest.cc @@ -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); diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc index f2cfa9cd..6f8458d0 100644 --- a/test/DefaultBtProgressInfoFileTest.cc +++ b/test/DefaultBtProgressInfoFileTest.cc @@ -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); } diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc index b537d8ef..905e4bba 100644 --- a/test/DefaultBtRequestFactoryTest.cc +++ b/test/DefaultBtRequestFactoryTest.cc @@ -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() { diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc index bc268731..082d6d29 100644 --- a/test/DefaultPieceStorageTest.cc +++ b/test/DefaultPieceStorageTest.cc @@ -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)); } } diff --git a/test/GrowSegmentTest.cc b/test/GrowSegmentTest.cc index 6f8fdcb8..4ecefbd8 100644 --- a/test/GrowSegmentTest.cc +++ b/test/GrowSegmentTest.cc @@ -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 diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h index 8987a0a9..9307675b 100644 --- a/test/MockBtRequestFactory.h +++ b/test/MockBtRequestFactory.h @@ -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 diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h index be3c43f1..2f5a7434 100644 --- a/test/MockPieceStorage.h +++ b/test/MockPieceStorage.h @@ -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(); } diff --git a/test/PieceTest.cc b/test/PieceTest.cc index 516f3f31..52b461ec 100644 --- a/test/PieceTest.cc +++ b/test/PieceTest.cc @@ -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 diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc index 580d2019..495d98e5 100644 --- a/test/SegmentManTest.cc +++ b/test/SegmentManTest.cc @@ -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() diff --git a/test/SegmentTest.cc b/test/SegmentTest.cc index 1d500e93..4644a648 100644 --- a/test/SegmentTest.cc +++ b/test/SegmentTest.cc @@ -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 |