mirror of https://github.com/aria2/aria2
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.hpull/1/head
parent
aa669e8646
commit
518a200d57
39
ChangeLog
39
ChangeLog
|
@ -1,3 +1,42 @@
|
|||
2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
|
||||
|
||||
Type clarification: size_t for length or size, uint64_t for file
|
||||
length, off_t for file offset.
|
||||
|
||||
* src/PiecedSegment.cc
|
||||
* src/GrowSegment.h
|
||||
* src/DefaultBtRequestFactory.h
|
||||
* src/DefaultBtProgressInfoFile.cc
|
||||
* src/UnknownLengthPieceStorage.h
|
||||
* src/DefaultPieceStorage.cc
|
||||
* src/UnknownLengthPieceStorage.cc
|
||||
* src/DefaultBtInteractive.cc
|
||||
* src/GrowSegment.cc
|
||||
* src/BitfieldMan.h
|
||||
* src/DownloadCommand.cc
|
||||
* src/BtRequestFactory.h
|
||||
* src/PiecedSegment.h
|
||||
* src/DefaultPieceStorage.h
|
||||
* src/Piece.cc
|
||||
* src/DefaultBtRequestFactory.cc
|
||||
* src/PieceStorage.h
|
||||
* src/Segment.h
|
||||
* src/Piece.h
|
||||
* src/BitfieldMan.cc
|
||||
* src/Util.cc
|
||||
* test/DefaultBtProgressInfoFileTest.cc
|
||||
* test/DefaultPieceStorageTest.cc
|
||||
* test/MockPieceStorage.h
|
||||
* test/BtRequestMessageTest.cc
|
||||
* test/DefaultBtMessageDispatcherTest.cc
|
||||
* test/BitfieldManTest.cc
|
||||
* test/GrowSegmentTest.cc
|
||||
* test/PieceTest.cc
|
||||
* test/SegmentTest.cc
|
||||
* test/SegmentManTest.cc
|
||||
* test/DefaultBtRequestFactoryTest.cc
|
||||
* test/MockBtRequestFactory.h
|
||||
|
||||
2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
|
||||
|
||||
Fixed compilation error with --disable-nls
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
|
||||
namespace aria2 {
|
||||
|
||||
BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
|
||||
BitfieldMan::BitfieldMan(size_t blockLength, uint64_t totalLength)
|
||||
:blockLength(blockLength),
|
||||
totalLength(totalLength),
|
||||
bitfield(0),
|
||||
|
@ -138,42 +138,45 @@ BitfieldMan::~BitfieldMan() {
|
|||
delete [] filterBitfield;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getBlockLength() const
|
||||
size_t BitfieldMan::getBlockLength() const
|
||||
{
|
||||
return blockLength;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getLastBlockLength() const
|
||||
size_t BitfieldMan::getLastBlockLength() const
|
||||
{
|
||||
return totalLength-blockLength*(blocks-1);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getBlockLength(int32_t index) const
|
||||
size_t BitfieldMan::getBlockLength(size_t index) const
|
||||
{
|
||||
if(index == blocks-1) {
|
||||
return getLastBlockLength();
|
||||
} else if(0 <= index && index < blocks-1) {
|
||||
} else if(index < blocks-1) {
|
||||
return getBlockLength();
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countSetBit(const unsigned char* bitfield, int32_t len) const {
|
||||
int32_t count = 0;
|
||||
int32_t size = sizeof(int32_t);
|
||||
for(int32_t i = 0; i < len/size; ++i) {
|
||||
count += Util::countBit(*(uint32_t*)&bitfield[i*size]);
|
||||
size_t BitfieldMan::countSetBit(const unsigned char* bitfield, size_t len) const {
|
||||
size_t count = 0;
|
||||
size_t size = sizeof(uint32_t);
|
||||
size_t to = len/size;
|
||||
for(size_t i = 0; i < to; ++i) {
|
||||
count += Util::countBit(*reinterpret_cast<const uint32_t*>(&bitfield[i*size]));
|
||||
}
|
||||
for(int32_t i = len-len%size; i < len; i++) {
|
||||
count += Util::countBit((uint32_t)bitfield[i]);
|
||||
for(size_t i = len-len%size; i < len; i++) {
|
||||
count += Util::countBit(static_cast<uint32_t>(bitfield[i]));
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) const {
|
||||
int32_t index = -1;
|
||||
for(int bs = 7; bs >= 0; bs--) {
|
||||
size_t
|
||||
BitfieldMan::getNthBitIndex(const unsigned char bitfield, size_t nth) const
|
||||
{
|
||||
size_t index = 0;
|
||||
for(size_t bs = 7; bs >= 0; bs--) {
|
||||
unsigned char mask = 1 << bs;
|
||||
if(bitfield & mask) {
|
||||
nth--;
|
||||
|
@ -187,27 +190,22 @@ int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) c
|
|||
}
|
||||
|
||||
template<typename Array>
|
||||
int32_t
|
||||
BitfieldMan::getMissingIndexRandomly(const Array& bitfield,
|
||||
int32_t bitfieldLength) const
|
||||
bool BitfieldMan::getMissingIndexRandomly(size_t& index,
|
||||
const Array& bitfield,
|
||||
size_t bitfieldLength) const
|
||||
{
|
||||
/*
|
||||
int32_t byte = (int32_t)(((double)bitfieldLength)*
|
||||
randomizer->getRandomNumber()/
|
||||
(randomizer->getMaxRandomNumber()+1.0));
|
||||
*/
|
||||
int32_t byte = randomizer->getRandomNumber(bitfieldLength);
|
||||
size_t byte = randomizer->getRandomNumber(bitfieldLength);
|
||||
|
||||
unsigned char lastMask = 0;
|
||||
// the number of bytes in the last byte of bitfield
|
||||
int32_t lastByteLength = totalLength%(blockLength*8);
|
||||
size_t lastByteLength = totalLength%(blockLength*8);
|
||||
// the number of block in the last byte of bitfield
|
||||
int32_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength);
|
||||
for(int32_t i = 0; i < lastBlockCount; ++i) {
|
||||
size_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength);
|
||||
for(size_t i = 0; i < lastBlockCount; ++i) {
|
||||
lastMask >>= 1;
|
||||
lastMask |= 0x80;
|
||||
}
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
unsigned char mask;
|
||||
if(byte == bitfieldLength-1) {
|
||||
mask = lastMask;
|
||||
|
@ -215,23 +213,23 @@ BitfieldMan::getMissingIndexRandomly(const Array& bitfield,
|
|||
mask = 0xff;
|
||||
}
|
||||
if(bitfield[byte]&mask) {
|
||||
int32_t index = byte*8+getNthBitIndex(bitfield[byte], 1);
|
||||
return index;
|
||||
index = byte*8+getNthBitIndex(bitfield[byte], 1);
|
||||
return true;
|
||||
}
|
||||
byte++;
|
||||
if(byte == bitfieldLength) {
|
||||
byte = 0;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t length) const {
|
||||
bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, size_t length) const {
|
||||
if(bitfieldLength != length) {
|
||||
return false;
|
||||
}
|
||||
bool retval = false;
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
unsigned char temp = peerBitfield[i] & ~bitfield[i];
|
||||
if(filterEnabled) {
|
||||
temp &= filterBitfield[i];
|
||||
|
@ -244,20 +242,20 @@ bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t len
|
|||
return retval;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getMissingIndex(const unsigned char* peerBitfield, int32_t length) const {
|
||||
bool BitfieldMan::getMissingIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
|
||||
if(bitfieldLength != length) {
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
array_fun<unsigned char> bf = array_and(array_negate(bitfield), peerBitfield);
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getMissingIndexRandomly(bf, bitfieldLength);
|
||||
return getMissingIndexRandomly(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, int32_t length) const {
|
||||
bool BitfieldMan::getMissingUnusedIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
|
||||
if(bitfieldLength != length) {
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
array_fun<unsigned char> bf = array_and(array_and(array_negate(bitfield),
|
||||
array_negate(useBitfield)),
|
||||
|
@ -265,72 +263,75 @@ int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, in
|
|||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getMissingIndexRandomly(bf, bitfieldLength);
|
||||
return getMissingIndexRandomly(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
template<typename Array>
|
||||
int32_t BitfieldMan::getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const
|
||||
bool BitfieldMan::getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const
|
||||
{
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
int32_t base = i*8;
|
||||
for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
size_t base = i*8;
|
||||
for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
|
||||
unsigned char mask = 128 >> bi;
|
||||
if(bitfield[i] & mask) {
|
||||
return base+bi;
|
||||
index = base+bi;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getFirstMissingUnusedIndex() const {
|
||||
bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const
|
||||
{
|
||||
array_fun<unsigned char> bf = array_and(array_negate(bitfield),
|
||||
array_negate(useBitfield));
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getFirstMissingIndex(bf, bitfieldLength);
|
||||
return getFirstMissingIndex(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getFirstMissingIndex() const
|
||||
bool BitfieldMan::getFirstMissingIndex(size_t& index) const
|
||||
{
|
||||
array_fun<unsigned char> bf = array_negate(bitfield);
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getFirstMissingIndex(bf, bitfieldLength);
|
||||
return getFirstMissingIndex(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getMissingIndex() const {
|
||||
bool BitfieldMan::getMissingIndex(size_t& index) const {
|
||||
array_fun<unsigned char> bf = array_negate(bitfield);
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getMissingIndexRandomly(bf, bitfieldLength);
|
||||
return getMissingIndexRandomly(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getMissingUnusedIndex() const {
|
||||
bool BitfieldMan::getMissingUnusedIndex(size_t& index) const
|
||||
{
|
||||
array_fun<unsigned char> bf = array_and(array_negate(bitfield),
|
||||
array_negate(useBitfield));
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
}
|
||||
return getMissingIndexRandomly(bf, bitfieldLength);
|
||||
return getMissingIndexRandomly(index, bf, bitfieldLength);
|
||||
}
|
||||
|
||||
// [startIndex, endIndex)
|
||||
class Range {
|
||||
public:
|
||||
int32_t startIndex;
|
||||
int32_t endIndex;
|
||||
Range(int32_t startIndex = 0, int32_t endIndex = 0):startIndex(startIndex),
|
||||
endIndex(endIndex) {}
|
||||
size_t startIndex;
|
||||
size_t endIndex;
|
||||
Range(size_t startIndex = 0, size_t endIndex = 0):startIndex(startIndex),
|
||||
endIndex(endIndex) {}
|
||||
|
||||
int32_t getSize() const {
|
||||
size_t getSize() const {
|
||||
return endIndex-startIndex;
|
||||
}
|
||||
|
||||
int32_t getMidIndex() const {
|
||||
size_t getMidIndex() const {
|
||||
return (endIndex-startIndex)/2+startIndex;
|
||||
}
|
||||
|
||||
|
@ -339,59 +340,63 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
int32_t BitfieldMan::getStartIndex(int32_t index) const {
|
||||
size_t BitfieldMan::getStartIndex(size_t index) const {
|
||||
while(index < blocks && (isUseBitSet(index) || isBitSet(index))) {
|
||||
index++;
|
||||
}
|
||||
if((int32_t)blocks <= index) {
|
||||
return -1;
|
||||
if(blocks <= index) {
|
||||
return blocks;
|
||||
} else {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getEndIndex(int32_t index) const {
|
||||
size_t BitfieldMan::getEndIndex(size_t index) const {
|
||||
while(index < blocks && (!isUseBitSet(index) && !isBitSet(index))) {
|
||||
index++;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getSparseMissingUnusedIndex() const {
|
||||
bool BitfieldMan::getSparseMissingUnusedIndex(size_t& index) const {
|
||||
Range maxRange;
|
||||
int32_t index = 0;
|
||||
Range currentRange;
|
||||
while(index < blocks) {
|
||||
currentRange.startIndex = getStartIndex(index);
|
||||
if(currentRange.startIndex == -1) {
|
||||
break;
|
||||
{
|
||||
size_t nextIndex = 0;
|
||||
while(nextIndex < blocks) {
|
||||
currentRange.startIndex = getStartIndex(nextIndex);
|
||||
if(currentRange.startIndex == blocks) {
|
||||
break;
|
||||
}
|
||||
currentRange.endIndex = getEndIndex(currentRange.startIndex);
|
||||
if(maxRange < currentRange) {
|
||||
maxRange = currentRange;
|
||||
}
|
||||
nextIndex = currentRange.endIndex;
|
||||
}
|
||||
currentRange.endIndex = getEndIndex(currentRange.startIndex);
|
||||
if(maxRange < currentRange) {
|
||||
maxRange = currentRange;
|
||||
}
|
||||
index = currentRange.endIndex;
|
||||
}
|
||||
if(maxRange.getSize()) {
|
||||
if(maxRange.startIndex == 0) {
|
||||
return 0;
|
||||
index = 0;
|
||||
} else if(isUseBitSet(maxRange.startIndex-1)) {
|
||||
return maxRange.getMidIndex();
|
||||
index = maxRange.getMidIndex();
|
||||
} else {
|
||||
return maxRange.startIndex;
|
||||
index = maxRange.startIndex;
|
||||
}
|
||||
return true;
|
||||
} else {
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Array>
|
||||
std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const
|
||||
std::deque<size_t>
|
||||
BitfieldMan::getAllMissingIndexes(const Array& bitfield, size_t bitfieldLength) const
|
||||
{
|
||||
std::deque<int32_t> missingIndexes;
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
int32_t base = i*8;
|
||||
for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
|
||||
std::deque<size_t> missingIndexes;
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
size_t base = i*8;
|
||||
for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
|
||||
unsigned char mask = 128 >> bi;
|
||||
if(bitfield[i] & mask) {
|
||||
missingIndexes.push_back(base+bi);
|
||||
|
@ -401,7 +406,7 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int
|
|||
return missingIndexes;
|
||||
}
|
||||
|
||||
std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
|
||||
std::deque<size_t> BitfieldMan::getAllMissingIndexes() const {
|
||||
array_fun<unsigned char> bf = array_negate(bitfield);
|
||||
if(filterEnabled) {
|
||||
bf = array_and(bf, filterBitfield);
|
||||
|
@ -409,9 +414,9 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
|
|||
return getAllMissingIndexes(bf, bitfieldLength);
|
||||
}
|
||||
|
||||
std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, int32_t peerBitfieldLength) const {
|
||||
std::deque<size_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, size_t peerBitfieldLength) const {
|
||||
if(bitfieldLength != peerBitfieldLength) {
|
||||
return std::deque<int32_t>();
|
||||
return std::deque<size_t>();
|
||||
}
|
||||
array_fun<unsigned char> bf = array_and(array_negate(bitfield),
|
||||
peerBitfield);
|
||||
|
@ -421,17 +426,17 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerB
|
|||
return getAllMissingIndexes(bf, bitfieldLength);
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countMissingBlock() const {
|
||||
size_t BitfieldMan::countMissingBlock() const {
|
||||
return cachedNumMissingBlock;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countMissingBlockNow() const {
|
||||
size_t BitfieldMan::countMissingBlockNow() const {
|
||||
if(filterEnabled) {
|
||||
unsigned char* temp = new unsigned char[bitfieldLength];
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
temp[i] = bitfield[i]&filterBitfield[i];
|
||||
}
|
||||
int32_t count = countSetBit(filterBitfield, bitfieldLength)-
|
||||
size_t count = countSetBit(filterBitfield, bitfieldLength)-
|
||||
countSetBit(temp, bitfieldLength);
|
||||
delete [] temp;
|
||||
return count;
|
||||
|
@ -440,15 +445,15 @@ int32_t BitfieldMan::countMissingBlockNow() const {
|
|||
}
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countFilteredBlock() const {
|
||||
size_t BitfieldMan::countFilteredBlock() const {
|
||||
return cachedNumFilteredBlock;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countBlock() const {
|
||||
size_t BitfieldMan::countBlock() const {
|
||||
return blocks;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::countFilteredBlockNow() const {
|
||||
size_t BitfieldMan::countFilteredBlockNow() const {
|
||||
if(filterEnabled) {
|
||||
return countSetBit(filterBitfield, bitfieldLength);
|
||||
} else {
|
||||
|
@ -456,12 +461,12 @@ int32_t BitfieldMan::countFilteredBlockNow() const {
|
|||
}
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getMaxIndex() const
|
||||
size_t BitfieldMan::getMaxIndex() const
|
||||
{
|
||||
return blocks-1;
|
||||
}
|
||||
|
||||
bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on) {
|
||||
bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) {
|
||||
if(blocks <= index) { return false; }
|
||||
unsigned char mask = 128 >> index%8;
|
||||
if(on) {
|
||||
|
@ -472,21 +477,21 @@ bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BitfieldMan::setUseBit(int32_t index) {
|
||||
bool BitfieldMan::setUseBit(size_t index) {
|
||||
return setBitInternal(useBitfield, index, true);
|
||||
}
|
||||
|
||||
bool BitfieldMan::unsetUseBit(int32_t index) {
|
||||
bool BitfieldMan::unsetUseBit(size_t index) {
|
||||
return setBitInternal(useBitfield, index, false);
|
||||
}
|
||||
|
||||
bool BitfieldMan::setBit(int32_t index) {
|
||||
bool BitfieldMan::setBit(size_t index) {
|
||||
bool b = setBitInternal(bitfield, index, true);
|
||||
updateCache();
|
||||
return b;
|
||||
}
|
||||
|
||||
bool BitfieldMan::unsetBit(int32_t index) {
|
||||
bool BitfieldMan::unsetBit(size_t index) {
|
||||
bool b = setBitInternal(bitfield, index, false);
|
||||
updateCache();
|
||||
return b;
|
||||
|
@ -494,7 +499,7 @@ bool BitfieldMan::unsetBit(int32_t index) {
|
|||
|
||||
bool BitfieldMan::isFilteredAllBitSet() const {
|
||||
if(filterEnabled) {
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
if((bitfield[i]&filterBitfield[i]) != filterBitfield[i]) {
|
||||
return false;
|
||||
}
|
||||
|
@ -509,7 +514,7 @@ bool BitfieldMan::isAllBitSet() const {
|
|||
if(bitfieldLength == 0) {
|
||||
return true;
|
||||
}
|
||||
for(int32_t i = 0; i < bitfieldLength-1; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength-1; ++i) {
|
||||
if(bitfield[i] != 0xff) {
|
||||
return false;
|
||||
}
|
||||
|
@ -521,21 +526,21 @@ bool BitfieldMan::isAllBitSet() const {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, int32_t index) const {
|
||||
bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, size_t index) const {
|
||||
if(index < 0 || blocks <= index) { return false; }
|
||||
unsigned char mask = 128 >> index%8;
|
||||
return (bitfield[index/8] & mask) != 0;
|
||||
}
|
||||
|
||||
bool BitfieldMan::isBitSet(int32_t index) const {
|
||||
bool BitfieldMan::isBitSet(size_t index) const {
|
||||
return isBitSetInternal(bitfield, index);
|
||||
}
|
||||
|
||||
bool BitfieldMan::isUseBitSet(int32_t index) const {
|
||||
bool BitfieldMan::isUseBitSet(size_t index) const {
|
||||
return isBitSetInternal(useBitfield, index);
|
||||
}
|
||||
|
||||
void BitfieldMan::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) {
|
||||
void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) {
|
||||
if(this->bitfieldLength != bitfieldLength) {
|
||||
return;
|
||||
}
|
||||
|
@ -549,7 +554,7 @@ const unsigned char* BitfieldMan::getBitfield() const
|
|||
return bitfield;
|
||||
}
|
||||
|
||||
int32_t BitfieldMan::getBitfieldLength() const
|
||||
size_t BitfieldMan::getBitfieldLength() const
|
||||
{
|
||||
return bitfieldLength;
|
||||
}
|
||||
|
@ -560,7 +565,7 @@ void BitfieldMan::clearAllBit() {
|
|||
}
|
||||
|
||||
void BitfieldMan::setAllBit() {
|
||||
for(int32_t i = 0; i < blocks; ++i) {
|
||||
for(size_t i = 0; i < blocks; ++i) {
|
||||
setBitInternal(bitfield, i, true);
|
||||
}
|
||||
updateCache();
|
||||
|
@ -572,23 +577,23 @@ void BitfieldMan::clearAllUseBit() {
|
|||
}
|
||||
|
||||
void BitfieldMan::setAllUseBit() {
|
||||
for(int32_t i = 0; i < blocks; ++i) {
|
||||
for(size_t i = 0; i < blocks; ++i) {
|
||||
setBitInternal(useBitfield, i, true);
|
||||
}
|
||||
}
|
||||
|
||||
bool BitfieldMan::setFilterBit(int32_t index) {
|
||||
bool BitfieldMan::setFilterBit(size_t index) {
|
||||
return setBitInternal(filterBitfield, index, true);
|
||||
}
|
||||
|
||||
void BitfieldMan::addFilter(int64_t offset, int64_t length) {
|
||||
void BitfieldMan::addFilter(uint64_t offset, uint64_t length) {
|
||||
if(!filterBitfield) {
|
||||
filterBitfield = new unsigned char[bitfieldLength];
|
||||
memset(filterBitfield, 0, bitfieldLength);
|
||||
}
|
||||
int32_t startBlock = offset/blockLength;
|
||||
int32_t endBlock = (offset+length-1)/blockLength;
|
||||
for(int i = startBlock; i <= endBlock && i < blocks; i++) {
|
||||
size_t startBlock = offset/blockLength;
|
||||
size_t endBlock = (offset+length-1)/blockLength;
|
||||
for(size_t i = startBlock; i <= endBlock && i < blocks; i++) {
|
||||
setFilterBit(i);
|
||||
}
|
||||
updateCache();
|
||||
|
@ -617,29 +622,29 @@ bool BitfieldMan::isFilterEnabled() const {
|
|||
return filterEnabled;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getFilteredTotalLength() const {
|
||||
uint64_t BitfieldMan::getFilteredTotalLength() const {
|
||||
return cachedFilteredTotalLength;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getFilteredTotalLengthNow() const {
|
||||
uint64_t BitfieldMan::getFilteredTotalLengthNow() const {
|
||||
if(!filterBitfield) {
|
||||
return 0;
|
||||
}
|
||||
int32_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength);
|
||||
size_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength);
|
||||
if(filteredBlocks == 0) {
|
||||
return 0;
|
||||
}
|
||||
if(isBitSetInternal(filterBitfield, blocks-1)) {
|
||||
return ((int64_t)filteredBlocks-1)*blockLength+getLastBlockLength();
|
||||
return ((uint64_t)filteredBlocks-1)*blockLength+getLastBlockLength();
|
||||
} else {
|
||||
return ((int64_t)filteredBlocks)*blockLength;
|
||||
return ((uint64_t)filteredBlocks)*blockLength;
|
||||
}
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
|
||||
uint64_t BitfieldMan::getCompletedLength(bool useFilter) const {
|
||||
unsigned char* temp = new unsigned char[bitfieldLength];
|
||||
if(useFilter) {
|
||||
for(int32_t i = 0; i < bitfieldLength; ++i) {
|
||||
for(size_t i = 0; i < bitfieldLength; ++i) {
|
||||
temp[i] = bitfield[i];
|
||||
if(filterEnabled) {
|
||||
temp[i] &= filterBitfield[i];
|
||||
|
@ -648,34 +653,34 @@ int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
|
|||
} else {
|
||||
memcpy(temp, bitfield, bitfieldLength);
|
||||
}
|
||||
int32_t completedBlocks = countSetBit(temp, bitfieldLength);
|
||||
int64_t completedLength = 0;
|
||||
size_t completedBlocks = countSetBit(temp, bitfieldLength);
|
||||
uint64_t completedLength = 0;
|
||||
if(completedBlocks == 0) {
|
||||
completedLength = 0;
|
||||
} else {
|
||||
if(isBitSetInternal(temp, blocks-1)) {
|
||||
completedLength = ((int64_t)completedBlocks-1)*blockLength+getLastBlockLength();
|
||||
completedLength = ((uint64_t)completedBlocks-1)*blockLength+getLastBlockLength();
|
||||
} else {
|
||||
completedLength = ((int64_t)completedBlocks)*blockLength;
|
||||
completedLength = ((uint64_t)completedBlocks)*blockLength;
|
||||
}
|
||||
}
|
||||
delete [] temp;
|
||||
return completedLength;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getCompletedLength() const {
|
||||
uint64_t BitfieldMan::getCompletedLength() const {
|
||||
return cachedCompletedLength;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getCompletedLengthNow() const {
|
||||
uint64_t BitfieldMan::getCompletedLengthNow() const {
|
||||
return getCompletedLength(false);
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getFilteredCompletedLength() const {
|
||||
uint64_t BitfieldMan::getFilteredCompletedLength() const {
|
||||
return cachedFilteredComletedLength;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getFilteredCompletedLengthNow() const {
|
||||
uint64_t BitfieldMan::getFilteredCompletedLengthNow() const {
|
||||
return getCompletedLength(true);
|
||||
}
|
||||
|
||||
|
@ -688,9 +693,9 @@ void BitfieldMan::updateCache()
|
|||
cachedFilteredComletedLength = getFilteredCompletedLengthNow();
|
||||
}
|
||||
|
||||
bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const
|
||||
bool BitfieldMan::isBitRangeSet(size_t startIndex, size_t endIndex) const
|
||||
{
|
||||
for(int32_t i = startIndex; i <= endIndex; ++i) {
|
||||
for(size_t i = startIndex; i <= endIndex; ++i) {
|
||||
if(!isBitSet(i)) {
|
||||
return false;
|
||||
}
|
||||
|
@ -698,23 +703,23 @@ bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const
|
|||
return true;
|
||||
}
|
||||
|
||||
void BitfieldMan::unsetBitRange(int32_t startIndex, int32_t endIndex)
|
||||
void BitfieldMan::unsetBitRange(size_t startIndex, size_t endIndex)
|
||||
{
|
||||
for(int32_t i = startIndex; i <= endIndex; ++i) {
|
||||
for(size_t i = startIndex; i <= endIndex; ++i) {
|
||||
unsetBit(i);
|
||||
}
|
||||
updateCache();
|
||||
}
|
||||
|
||||
void BitfieldMan::setBitRange(int32_t startIndex, int32_t endIndex)
|
||||
void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex)
|
||||
{
|
||||
for(int32_t i = startIndex; i <= endIndex; ++i) {
|
||||
for(size_t i = startIndex; i <= endIndex; ++i) {
|
||||
setBit(i);
|
||||
}
|
||||
updateCache();
|
||||
}
|
||||
|
||||
bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
|
||||
bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const
|
||||
{
|
||||
if(length <= 0) {
|
||||
return false;
|
||||
|
@ -725,9 +730,9 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
|
|||
if(totalLength < offset+length) {
|
||||
length = totalLength-offset;
|
||||
}
|
||||
int32_t startBlock = offset/blockLength;
|
||||
int32_t endBlock = (offset+length-1)/blockLength;
|
||||
for(int32_t i = startBlock; i <= endBlock; i++) {
|
||||
size_t startBlock = offset/blockLength;
|
||||
size_t endBlock = (offset+length-1)/blockLength;
|
||||
for(size_t i = startBlock; i <= endBlock; i++) {
|
||||
if(!isBitSet(i)) {
|
||||
return false;
|
||||
}
|
||||
|
@ -735,13 +740,13 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
|
|||
return true;
|
||||
}
|
||||
|
||||
int64_t BitfieldMan::getMissingUnusedLength(int32_t startingIndex) const
|
||||
uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
|
||||
{
|
||||
if(startingIndex < 0 || blocks <= startingIndex) {
|
||||
return 0;
|
||||
}
|
||||
int64_t length = 0;
|
||||
for(int32_t i = startingIndex; i < blocks; ++i) {
|
||||
uint64_t length = 0;
|
||||
for(size_t i = startingIndex; i < blocks; ++i) {
|
||||
if(isBitSet(i) || isUseBitSet(i)) {
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
};
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -42,7 +42,7 @@ namespace aria2 {
|
|||
class GrowSegment:public Segment {
|
||||
private:
|
||||
SharedHandle<Piece> _piece;
|
||||
int32_t _writtenLength;
|
||||
size_t _writtenLength;
|
||||
public:
|
||||
GrowSegment(const SharedHandle<Piece>& piece);
|
||||
|
||||
|
@ -53,42 +53,42 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
virtual int32_t getIndex() const
|
||||
virtual size_t getIndex() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual int64_t getPosition() const
|
||||
virtual off_t getPosition() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual int64_t getPositionToWrite() const
|
||||
virtual off_t getPositionToWrite() const
|
||||
{
|
||||
return _writtenLength;
|
||||
}
|
||||
|
||||
virtual int32_t getLength() const
|
||||
virtual size_t getLength() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual int32_t getSegmentLength() const
|
||||
virtual size_t getSegmentLength() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual int32_t getWrittenLength() const
|
||||
virtual size_t getWrittenLength() const
|
||||
{
|
||||
return _writtenLength;
|
||||
}
|
||||
|
||||
virtual int32_t getOverflowLength() const
|
||||
virtual size_t getOverflowLength() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual void updateWrittenLength(int32_t bytes);
|
||||
virtual void updateWrittenLength(size_t bytes);
|
||||
|
||||
virtual void clear();
|
||||
|
||||
|
|
70
src/Piece.cc
70
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;
|
||||
}
|
||||
bitfield->setUseBit(blockIndex);
|
||||
return blockIndex;
|
||||
}
|
||||
|
||||
int32_t Piece::getMissingBlockIndex() const {
|
||||
int32_t blockIndex = bitfield->getMissingIndex();
|
||||
if(blockIndex == -1) {
|
||||
return blockIndex;
|
||||
}
|
||||
bitfield->setUseBit(blockIndex);
|
||||
return blockIndex;
|
||||
}
|
||||
|
||||
int32_t Piece::getFirstMissingBlockIndexWithoutLock() const
|
||||
bool Piece::getMissingUnusedBlockIndex(size_t& index) const
|
||||
{
|
||||
return bitfield->getFirstMissingIndex();
|
||||
if(bitfield->getFirstMissingUnusedIndex(index)) {
|
||||
bitfield->setUseBit(index);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
std::deque<int32_t> Piece::getAllMissingBlockIndexes() const {
|
||||
bool Piece::getMissingBlockIndex(size_t& index) const
|
||||
{
|
||||
if(bitfield->getMissingIndex(index)) {
|
||||
bitfield->setUseBit(index);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool Piece::getFirstMissingBlockIndexWithoutLock(size_t& index) const
|
||||
{
|
||||
return bitfield->getFirstMissingIndex(index);
|
||||
}
|
||||
|
||||
std::deque<size_t> Piece::getAllMissingBlockIndexes() const {
|
||||
return bitfield->getAllMissingIndexes();
|
||||
}
|
||||
|
||||
|
@ -175,7 +177,7 @@ std::string Piece::toString() const {
|
|||
return "piece: index="+Util::itos(index)+", length="+Util::itos(length);
|
||||
}
|
||||
|
||||
void Piece::reconfigure(int32_t length)
|
||||
void Piece::reconfigure(size_t length)
|
||||
{
|
||||
delete bitfield;
|
||||
this->length = length;
|
||||
|
@ -183,12 +185,12 @@ void Piece::reconfigure(int32_t length)
|
|||
BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
|
||||
}
|
||||
|
||||
void Piece::setBitfield(const unsigned char* bitfield, int32_t len)
|
||||
void Piece::setBitfield(const unsigned char* bitfield, size_t len)
|
||||
{
|
||||
this->bitfield->setBitfield(bitfield, len);
|
||||
}
|
||||
|
||||
int32_t Piece::getCompletedLength()
|
||||
size_t Piece::getCompletedLength()
|
||||
{
|
||||
return bitfield->getCompletedLength();
|
||||
}
|
||||
|
|
50
src/Piece.h
50
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;
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -63,38 +63,64 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BitfieldManTest );
|
|||
|
||||
void BitfieldManTest::testGetBlockSize() {
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt1.getBlockLength(9));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1024, bt1.getBlockLength(9));
|
||||
|
||||
BitfieldMan bt2(1024, 1024*10+1);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt2.getBlockLength(9));
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1, bt2.getBlockLength(10));
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)0, bt2.getBlockLength(11));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1024, bt2.getBlockLength(9));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, bt2.getBlockLength(10));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, bt2.getBlockLength(11));
|
||||
}
|
||||
|
||||
void BitfieldManTest::testGetFirstMissingUnusedIndex()
|
||||
{
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.setUseBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.unsetUseBit(0);
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(!bt1.getFirstMissingUnusedIndex(index));
|
||||
}
|
||||
}
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
||||
bt1.addFilter(1024, 1024*10);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
}
|
||||
bt1.setBit(2);
|
||||
CPPUNIT_ASSERT_EQUAL(3, bt1.getFirstMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -102,26 +128,52 @@ void BitfieldManTest::testGetFirstMissingIndex()
|
|||
{
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.setUseBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.unsetUseBit(0);
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(!bt1.getFirstMissingIndex(index));
|
||||
}
|
||||
}
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
||||
bt1.addFilter(1024, 1024*10);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -130,15 +182,29 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
|
|||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
bt1.setRandomizer(fixedNumberRandomizer);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.setUseBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.unsetUseBit(0);
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
|
||||
}
|
||||
}
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
@ -146,11 +212,23 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
|
|||
|
||||
bt1.addFilter(1024, 1024*10);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
}
|
||||
bt1.setBit(2);
|
||||
CPPUNIT_ASSERT_EQUAL(3, bt1.getMissingUnusedIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -159,15 +237,29 @@ void BitfieldManTest::testGetMissingIndex_noarg()
|
|||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
bt1.setRandomizer(fixedNumberRandomizer);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.setUseBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
}
|
||||
bt1.unsetUseBit(0);
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
|
||||
}
|
||||
}
|
||||
{
|
||||
BitfieldMan bt1(1024, 1024*10);
|
||||
|
@ -175,11 +267,23 @@ void BitfieldManTest::testGetMissingIndex_noarg()
|
|||
|
||||
bt1.addFilter(1024, 1024*10);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
}
|
||||
bt1.setBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingIndex());
|
||||
{
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -189,12 +293,12 @@ void BitfieldManTest::testIsAllBitSet() {
|
|||
bt1.setBit(1);
|
||||
CPPUNIT_ASSERT(!bt1.isAllBitSet());
|
||||
|
||||
for(int i = 0; i < 8; i++) {
|
||||
for(size_t i = 0; i < 8; i++) {
|
||||
CPPUNIT_ASSERT(bt1.setBit(i));
|
||||
}
|
||||
CPPUNIT_ASSERT(!bt1.isAllBitSet());
|
||||
|
||||
for(int32_t i = 0; i < bt1.countBlock(); i++) {
|
||||
for(size_t i = 0; i < bt1.countBlock(); i++) {
|
||||
CPPUNIT_ASSERT(bt1.setBit(i));
|
||||
}
|
||||
CPPUNIT_ASSERT(bt1.isAllBitSet());
|
||||
|
@ -213,29 +317,27 @@ void BitfieldManTest::testFilter() {
|
|||
unsigned char peerBt[2];
|
||||
memset(peerBt, 0xff, sizeof(peerBt));
|
||||
|
||||
int index;
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(2, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(3, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(4, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(5, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(6, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(7, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(-1, index);
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)12, btman.getFilteredTotalLength());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
|
||||
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
CPPUNIT_ASSERT_EQUAL(12ULL, btman.getFilteredTotalLength());
|
||||
|
||||
// test offset=5, length=2
|
||||
btman.clearAllBit();
|
||||
|
@ -243,24 +345,22 @@ void BitfieldManTest::testFilter() {
|
|||
btman.clearFilter();
|
||||
btman.addFilter(5, 2);
|
||||
btman.enableFilter();
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
btman.setBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(2, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
btman.setUseBit(index);
|
||||
btman.setBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(3, index);
|
||||
index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
|
||||
btman.setUseBit(index);
|
||||
CPPUNIT_ASSERT_EQUAL(-1, index);
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)4, btman.getFilteredTotalLength());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
|
||||
CPPUNIT_ASSERT_EQUAL(4ULL, btman.getFilteredTotalLength());
|
||||
CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
|
||||
|
||||
BitfieldMan btman2(2, 31);
|
||||
btman2.addFilter(0, 31);
|
||||
btman2.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)31, btman2.getFilteredTotalLength());
|
||||
CPPUNIT_ASSERT_EQUAL(31ULL, btman2.getFilteredTotalLength());
|
||||
|
||||
}
|
||||
|
||||
|
@ -278,11 +378,14 @@ void BitfieldManTest::testGetMissingIndex() {
|
|||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
};
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)0, bt1.getMissingIndex(bitArray, 32));
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
|
||||
bt1.addFilter(1024, 1024*256);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1, bt1.getMissingIndex(bitArray, 32));
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
bt1.disableFilter();
|
||||
|
||||
unsigned char bitArray2[] = {
|
||||
|
@ -296,7 +399,8 @@ void BitfieldManTest::testGetMissingIndex() {
|
|||
0xff, 0xff, 0xff, 0xff,
|
||||
};
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)4, bt1.getMissingIndex(bitArray2, 32));
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray2, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
|
||||
|
||||
unsigned char bitArray3[] = {
|
||||
0x00, 0xff, 0xff, 0xff,
|
||||
|
@ -309,7 +413,8 @@ void BitfieldManTest::testGetMissingIndex() {
|
|||
0xff, 0xff, 0xff, 0xff,
|
||||
};
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)8, bt1.getMissingIndex(bitArray3, 32));
|
||||
CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray3, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
|
||||
|
||||
unsigned char bitArray4[] = {
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
@ -322,71 +427,91 @@ void BitfieldManTest::testGetMissingIndex() {
|
|||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bt1.getMissingIndex(bitArray4, 32));
|
||||
CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
|
||||
|
||||
}
|
||||
|
||||
void BitfieldManTest::testGetSparceMissingUnusedIndex() {
|
||||
BitfieldMan bitfield(1024*1024, 10*1024*1024);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
bitfield.setUseBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
|
||||
bitfield.setUseBit(5);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
bitfield.setUseBit(3);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
|
||||
bitfield.setUseBit(8);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
bitfield.setUseBit(2);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
|
||||
bitfield.setUseBit(7);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
bitfield.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
|
||||
bitfield.setUseBit(4);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
|
||||
bitfield.setUseBit(6);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)9, index);
|
||||
bitfield.setUseBit(9);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
|
||||
}
|
||||
|
||||
void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() {
|
||||
BitfieldMan bitfield(1024*1024, 10*1024*1024);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
|
||||
size_t index;
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
bitfield.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
bitfield.setBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
bitfield.setBit(2);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)3, index);
|
||||
bitfield.setBit(3);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)4, index);
|
||||
bitfield.setBit(4);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)5, index);
|
||||
bitfield.setBit(5);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)6, index);
|
||||
bitfield.setBit(6);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)7, index);
|
||||
bitfield.setBit(7);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)8, index);
|
||||
bitfield.setBit(8);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)9, index);
|
||||
bitfield.setBit(9);
|
||||
CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
|
||||
CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
|
||||
}
|
||||
|
||||
void BitfieldManTest::testIsBitSetOffsetRange()
|
||||
{
|
||||
int64_t totalLength = (int64_t)4*1024*1024*1024;
|
||||
int64_t totalLength = 4ULL*1024*1024*1024;
|
||||
int32_t pieceLength = 4*1024*1024;
|
||||
BitfieldMan bitfield(pieceLength, totalLength);
|
||||
bitfield.setAllBit();
|
||||
|
||||
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0));
|
||||
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, -1));
|
||||
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100));
|
||||
CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100));
|
||||
|
||||
|
@ -412,91 +537,91 @@ void BitfieldManTest::testIsBitSetOffsetRange()
|
|||
|
||||
void BitfieldManTest::testGetMissingUnusedLength()
|
||||
{
|
||||
int64_t totalLength = 1024*10+10;
|
||||
int32_t blockLength = 1024;
|
||||
uint64_t totalLength = 1024*10+10;
|
||||
size_t blockLength = 1024;
|
||||
|
||||
BitfieldMan bf(blockLength, totalLength);
|
||||
|
||||
// from index 0 and all blocks are unused and not acquired.
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)totalLength, bf.getMissingUnusedLength(0));
|
||||
CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
|
||||
|
||||
// from index 10 and all blocks are unused and not acquired.
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)10, bf.getMissingUnusedLength(10));
|
||||
CPPUNIT_ASSERT_EQUAL(10ULL, bf.getMissingUnusedLength(10));
|
||||
|
||||
// from index -1
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(-1));
|
||||
CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(-1));
|
||||
|
||||
// from index 11
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(11));
|
||||
CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(11));
|
||||
|
||||
// from index 12
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(12));
|
||||
CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(12));
|
||||
|
||||
// from index 0 and 5th block is used.
|
||||
bf.setUseBit(5);
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)5*blockLength, bf.getMissingUnusedLength(0));
|
||||
CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getMissingUnusedLength(0));
|
||||
|
||||
// from index 0 and 4th block is acquired.
|
||||
bf.setBit(4);
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)4*blockLength, bf.getMissingUnusedLength(0));
|
||||
CPPUNIT_ASSERT_EQUAL(4ULL*blockLength, bf.getMissingUnusedLength(0));
|
||||
|
||||
// from index 1
|
||||
CPPUNIT_ASSERT_EQUAL((int64_t)3*blockLength, bf.getMissingUnusedLength(1));
|
||||
CPPUNIT_ASSERT_EQUAL(3ULL*blockLength, bf.getMissingUnusedLength(1));
|
||||
}
|
||||
|
||||
void BitfieldManTest::testSetBitRange()
|
||||
{
|
||||
int32_t blockLength = 1024*1024;
|
||||
int64_t totalLength = 10*blockLength;
|
||||
size_t blockLength = 1024*1024;
|
||||
uint64_t totalLength = 10*blockLength;
|
||||
|
||||
BitfieldMan bf(blockLength, totalLength);
|
||||
|
||||
bf.setBitRange(0, 4);
|
||||
|
||||
for(int32_t i = 0; i < 5; ++i) {
|
||||
for(size_t i = 0; i < 5; ++i) {
|
||||
CPPUNIT_ASSERT(bf.isBitSet(i));
|
||||
}
|
||||
for(int32_t i = 5; i < 10; ++i) {
|
||||
for(size_t i = 5; i < 10; ++i) {
|
||||
CPPUNIT_ASSERT(!bf.isBitSet(i));
|
||||
}
|
||||
CPPUNIT_ASSERT_EQUAL(int64_t(5*blockLength), bf.getCompletedLength());
|
||||
CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getCompletedLength());
|
||||
}
|
||||
|
||||
void BitfieldManTest::testGetAllMissingIndexes_noarg()
|
||||
{
|
||||
int32_t blockLength = 16*1024;
|
||||
int64_t totalLength = 1024*1024;
|
||||
size_t blockLength = 16*1024;
|
||||
uint64_t totalLength = 1024*1024;
|
||||
BitfieldMan bf(blockLength, totalLength);
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes().size());
|
||||
for(int32_t i = 0; i < 63; ++i) {
|
||||
for(size_t i = 0; i < 63; ++i) {
|
||||
bf.setBit(i);
|
||||
}
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, bf.getAllMissingIndexes().size());
|
||||
CPPUNIT_ASSERT_EQUAL(63, bf.getAllMissingIndexes().front());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)63, bf.getAllMissingIndexes().front());
|
||||
}
|
||||
|
||||
void BitfieldManTest::testGetAllMissingIndexes()
|
||||
{
|
||||
int32_t blockLength = 16*1024;
|
||||
int64_t totalLength = 1024*1024;
|
||||
size_t blockLength = 16*1024;
|
||||
uint64_t totalLength = 1024*1024;
|
||||
BitfieldMan bf(blockLength, totalLength);
|
||||
BitfieldMan peerBf(blockLength, totalLength);
|
||||
peerBf.setAllBit();
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(),
|
||||
peerBf.getBitfieldLength()).size());
|
||||
for(int32_t i = 0; i < 62; ++i) {
|
||||
for(size_t i = 0; i < 62; ++i) {
|
||||
bf.setBit(i);
|
||||
}
|
||||
peerBf.unsetBit(62);
|
||||
|
||||
{
|
||||
std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
|
||||
peerBf.getBitfieldLength());
|
||||
std::deque<size_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
|
||||
peerBf.getBitfieldLength());
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size());
|
||||
CPPUNIT_ASSERT_EQUAL(63, indexes.front());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)63, indexes.front());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -504,62 +629,68 @@ void BitfieldManTest::testGetMissingUnusedIndex()
|
|||
{
|
||||
BitfieldMan bt1(1024, 1024*256);
|
||||
bt1.setRandomizer(fixedNumberRandomizer);
|
||||
|
||||
unsigned char bitArray[] = {
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
};
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
size_t index;
|
||||
{
|
||||
unsigned char bitArray[] = {
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
0xff, 0xff, 0xff, 0xff,
|
||||
};
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, index);
|
||||
|
||||
bt1.addFilter(1024, 1024*256);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
bt1.disableFilter();
|
||||
bt1.addFilter(1024, 1024*256);
|
||||
bt1.enableFilter();
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)1, index);
|
||||
bt1.setUseBit(1);
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
bt1.disableFilter();
|
||||
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
bt1.setBit(0);
|
||||
CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)2, index);
|
||||
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
bt1.setAllBit();
|
||||
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
|
||||
bt1.clearAllBit();
|
||||
bt1.setAllUseBit();
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
|
||||
|
||||
unsigned char bitArray4[] = {
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray4, 32));
|
||||
bt1.clearAllBit();
|
||||
bt1.setAllUseBit();
|
||||
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
|
||||
}
|
||||
{
|
||||
unsigned char bitArray4[] = {
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray4, 32));
|
||||
}
|
||||
}
|
||||
|
||||
void BitfieldManTest::testCountFilteredBlock()
|
||||
{
|
||||
BitfieldMan bt(1024, 1024*256);
|
||||
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
|
||||
bt.addFilter(1024, 1024*256);
|
||||
bt.enableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL(255, bt.countFilteredBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)255, bt.countFilteredBlock());
|
||||
bt.disableFilter();
|
||||
CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
|
||||
CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
|
||||
}
|
||||
|
||||
} // namespace aria2
|
||||
|
|
|
@ -54,7 +54,7 @@ public:
|
|||
|
||||
class MockPieceStorage2 : public MockPieceStorage {
|
||||
public:
|
||||
virtual bool hasPiece(int index) {
|
||||
virtual bool hasPiece(size_t index) {
|
||||
return index == 1;
|
||||
}
|
||||
};
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
||||
}
|
||||
|
|
|
@ -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() {
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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
|
||||
|
|
Loading…
Reference in New Issue