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

12 files changed, 444 insertions, 313 deletions

diff --git a/test/BitfieldManTest.cc b/test/BitfieldManTest.cc
index 68ca78d1..3012b1e0 100644
--- a/test/BitfieldManTest.cc
+++ b/test/BitfieldManTest.cc
@@ -63,38 +63,64 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BitfieldManTest );
 
 void BitfieldManTest::testGetBlockSize() {
   BitfieldMan bt1(1024, 1024*10);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt1.getBlockLength(9));
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, bt1.getBlockLength(9));
 
   BitfieldMan bt2(1024, 1024*10+1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt2.getBlockLength(9));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bt2.getBlockLength(10));
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bt2.getBlockLength(11));
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, bt2.getBlockLength(9));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, bt2.getBlockLength(10));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt2.getBlockLength(11));
 }
 
 void BitfieldManTest::testGetFirstMissingUnusedIndex()
 {
   {
     BitfieldMan bt1(1024, 1024*10);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getFirstMissingUnusedIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
     bt1.setBit(2);
-    CPPUNIT_ASSERT_EQUAL(3, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+    }
   }
 }
 
@@ -102,26 +128,52 @@ void BitfieldManTest::testGetFirstMissingIndex()
 {
   {
     BitfieldMan bt1(1024, 1024*10);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getFirstMissingIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
   }
 }
 
@@ -130,15 +182,29 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
   {
     BitfieldMan bt1(1024, 1024*10);
     bt1.setRandomizer(fixedNumberRandomizer);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
@@ -146,11 +212,23 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
     bt1.setBit(2);
-    CPPUNIT_ASSERT_EQUAL(3, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+    }
   }
 }
 
@@ -159,15 +237,29 @@ void BitfieldManTest::testGetMissingIndex_noarg()
   {
     BitfieldMan bt1(1024, 1024*10);
     bt1.setRandomizer(fixedNumberRandomizer);
-
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
@@ -175,11 +267,23 @@ void BitfieldManTest::testGetMissingIndex_noarg()
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
   }
 }
 
@@ -189,12 +293,12 @@ void BitfieldManTest::testIsAllBitSet() {
   bt1.setBit(1);
   CPPUNIT_ASSERT(!bt1.isAllBitSet());
   
-  for(int i = 0; i < 8; i++) {
+  for(size_t i = 0; i < 8; i++) {
     CPPUNIT_ASSERT(bt1.setBit(i));
   }
   CPPUNIT_ASSERT(!bt1.isAllBitSet());
 
-  for(int32_t i = 0; i < bt1.countBlock(); i++) {
+  for(size_t i = 0; i < bt1.countBlock(); i++) {
     CPPUNIT_ASSERT(bt1.setBit(i));
   }
   CPPUNIT_ASSERT(bt1.isAllBitSet());
@@ -213,29 +317,27 @@ void BitfieldManTest::testFilter() {
   unsigned char peerBt[2];
   memset(peerBt, 0xff, sizeof(peerBt));
 
-  int index;
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
-  btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(2, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  size_t index;
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(3, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(4, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(5, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(6, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(7, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(-1, index);
-  CPPUNIT_ASSERT_EQUAL((int64_t)12, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
+  CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
+  CPPUNIT_ASSERT_EQUAL(12ULL, btman.getFilteredTotalLength());
 
   // test offset=5, length=2
   btman.clearAllBit();
@@ -243,24 +345,22 @@ void BitfieldManTest::testFilter() {
   btman.clearFilter();
   btman.addFilter(5, 2);
   btman.enableFilter();
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
   btman.setBit(index);
-  CPPUNIT_ASSERT_EQUAL(2, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
   btman.setBit(index);
-  CPPUNIT_ASSERT_EQUAL(3, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
-  btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(-1, index);
-  CPPUNIT_ASSERT_EQUAL((int64_t)4, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+  CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
+  CPPUNIT_ASSERT_EQUAL(4ULL, btman.getFilteredTotalLength());
   CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
 
   BitfieldMan btman2(2, 31);
   btman2.addFilter(0, 31);
   btman2.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((int64_t)31, btman2.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL(31ULL, btman2.getFilteredTotalLength());
 
 }
 
@@ -278,11 +378,14 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
   };
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bt1.getMissingIndex(bitArray, 32));
+  size_t index;
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   bt1.addFilter(1024, 1024*256);
   bt1.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bt1.getMissingIndex(bitArray, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bt1.disableFilter();
 
   unsigned char bitArray2[] = {
@@ -296,7 +399,8 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bt1.getMissingIndex(bitArray2, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray2, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
 
   unsigned char bitArray3[] = {
     0x00, 0xff, 0xff, 0xff,
@@ -309,7 +413,8 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bt1.getMissingIndex(bitArray3, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray3, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
 
   unsigned char bitArray4[] = {
     0x00, 0x00, 0x00, 0x00,
@@ -322,71 +427,91 @@ void BitfieldManTest::testGetMissingIndex() {
     0x00, 0x00, 0x00, 0x00,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bt1.getMissingIndex(bitArray4, 32));
+  CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
 
 }
 
 void BitfieldManTest::testGetSparceMissingUnusedIndex() {
   BitfieldMan bitfield(1024*1024, 10*1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
+  size_t index;
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   bitfield.setUseBit(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
   bitfield.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
   bitfield.setUseBit(3);
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
   bitfield.setUseBit(8);
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
   bitfield.setUseBit(2);
-  CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
   bitfield.setUseBit(7);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bitfield.setUseBit(1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
   bitfield.setUseBit(4);
-  CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
   bitfield.setUseBit(6);
-  CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)9, index);
   bitfield.setUseBit(9);
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
 }
 
 void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() {
   BitfieldMan bitfield(1024*1024, 10*1024*1024);
-
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
+  size_t index;
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   bitfield.setBit(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bitfield.setBit(1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
   bitfield.setBit(2);
-  CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
   bitfield.setBit(3);
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
   bitfield.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
   bitfield.setBit(5);
-  CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
   bitfield.setBit(6);
-  CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
   bitfield.setBit(7);
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
   bitfield.setBit(8);
-  CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)9, index);
   bitfield.setBit(9);
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
 }
 
 void BitfieldManTest::testIsBitSetOffsetRange()
 {
-  int64_t totalLength = (int64_t)4*1024*1024*1024;
+  int64_t totalLength = 4ULL*1024*1024*1024;
   int32_t pieceLength = 4*1024*1024;
   BitfieldMan bitfield(pieceLength, totalLength);
   bitfield.setAllBit();
 
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0));
-  CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, -1));
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100));
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100));
 
@@ -412,91 +537,91 @@ void BitfieldManTest::testIsBitSetOffsetRange()
 
 void BitfieldManTest::testGetMissingUnusedLength()
 {
-  int64_t totalLength = 1024*10+10;
-  int32_t blockLength = 1024;
+  uint64_t totalLength = 1024*10+10;
+  size_t blockLength = 1024;
 
   BitfieldMan bf(blockLength, totalLength);
 
   // from index 0 and all blocks are unused and not acquired.
-  CPPUNIT_ASSERT_EQUAL((int64_t)totalLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
 
   // from index 10 and all blocks are unused and not acquired.
-  CPPUNIT_ASSERT_EQUAL((int64_t)10, bf.getMissingUnusedLength(10));
+  CPPUNIT_ASSERT_EQUAL(10ULL, bf.getMissingUnusedLength(10));
 
   // from index -1
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(-1));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(-1));
 
   // from index 11
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(11));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(11));
 
   // from index 12
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(12));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(12));
 
   // from index 0 and 5th block is used.
   bf.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((int64_t)5*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getMissingUnusedLength(0));
 
   // from index 0 and 4th block is acquired.
   bf.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((int64_t)4*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(4ULL*blockLength, bf.getMissingUnusedLength(0));
 
   // from index 1
-  CPPUNIT_ASSERT_EQUAL((int64_t)3*blockLength, bf.getMissingUnusedLength(1));
+  CPPUNIT_ASSERT_EQUAL(3ULL*blockLength, bf.getMissingUnusedLength(1));
 }
 
 void BitfieldManTest::testSetBitRange()
 {
-  int32_t blockLength = 1024*1024;
-  int64_t totalLength = 10*blockLength;
+  size_t blockLength = 1024*1024;
+  uint64_t totalLength = 10*blockLength;
 
   BitfieldMan bf(blockLength, totalLength);
 
   bf.setBitRange(0, 4);
 
-  for(int32_t i = 0; i < 5; ++i) {
+  for(size_t i = 0; i < 5; ++i) {
     CPPUNIT_ASSERT(bf.isBitSet(i));
   }
-  for(int32_t i = 5; i < 10; ++i) {
+  for(size_t i = 5; i < 10; ++i) {
     CPPUNIT_ASSERT(!bf.isBitSet(i));
   }
-  CPPUNIT_ASSERT_EQUAL(int64_t(5*blockLength), bf.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getCompletedLength());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes_noarg()
 {
-  int32_t blockLength = 16*1024;
-  int64_t totalLength = 1024*1024;
+  size_t blockLength = 16*1024;
+  uint64_t totalLength = 1024*1024;
   BitfieldMan bf(blockLength, totalLength);
 
   CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes().size());
-  for(int32_t i = 0; i < 63; ++i) {
+  for(size_t i = 0; i < 63; ++i) {
     bf.setBit(i);
   }
   CPPUNIT_ASSERT_EQUAL((size_t)1, bf.getAllMissingIndexes().size());
-  CPPUNIT_ASSERT_EQUAL(63, bf.getAllMissingIndexes().front());
+  CPPUNIT_ASSERT_EQUAL((size_t)63, bf.getAllMissingIndexes().front());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes()
 {
-  int32_t blockLength = 16*1024;
-  int64_t totalLength = 1024*1024;
+  size_t blockLength = 16*1024;
+  uint64_t totalLength = 1024*1024;
   BitfieldMan bf(blockLength, totalLength);
   BitfieldMan peerBf(blockLength, totalLength);
   peerBf.setAllBit();
 
   CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(),
 							   peerBf.getBitfieldLength()).size());
-  for(int32_t i = 0; i < 62; ++i) {
+  for(size_t i = 0; i < 62; ++i) {
     bf.setBit(i);
   }
   peerBf.unsetBit(62);
 
   {
-    std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
-							  peerBf.getBitfieldLength());
+    std::deque<size_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
+							 peerBf.getBitfieldLength());
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size());
-    CPPUNIT_ASSERT_EQUAL(63, indexes.front());
+    CPPUNIT_ASSERT_EQUAL((size_t)63, indexes.front());
   }
 }
 
@@ -504,62 +629,68 @@ void BitfieldManTest::testGetMissingUnusedIndex()
 {
   BitfieldMan bt1(1024, 1024*256);
   bt1.setRandomizer(fixedNumberRandomizer);
-
-  unsigned char bitArray[] = {
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-  };
-  CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex(bitArray, 32));
+  size_t index;
+  {
+    unsigned char bitArray[] = {
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+    };
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   
-  bt1.addFilter(1024, 1024*256);
-  bt1.enableFilter();
-  CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex(bitArray, 32));
-  bt1.setUseBit(1);
-  CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
-  bt1.disableFilter();
+    bt1.addFilter(1024, 1024*256);
+    bt1.enableFilter();
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    bt1.setUseBit(1);
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    bt1.disableFilter();
 
-  bt1.setBit(0);
-  CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
+    bt1.setBit(0);
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)2, index);
 
-  bt1.setAllBit();
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
+    bt1.setAllBit();
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
   
-  bt1.clearAllBit();
-  bt1.setAllUseBit();
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
-
-  unsigned char bitArray4[] = {
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-  };
-
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray4, 32));
+    bt1.clearAllBit();
+    bt1.setAllUseBit();
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
+  }
+  {
+    unsigned char bitArray4[] = {
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+    };
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray4, 32));
+  }
 }
 
 void BitfieldManTest::testCountFilteredBlock()
 {
   BitfieldMan bt(1024, 1024*256);
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
   bt.addFilter(1024, 1024*256);
   bt.enableFilter();
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(255, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)255, bt.countFilteredBlock());
   bt.disableFilter();
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
 }
 
 } // namespace aria2
diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc
index 349f42cc..9b1cc8be 100644
--- a/test/BtRequestMessageTest.cc
+++ b/test/BtRequestMessageTest.cc
@@ -54,7 +54,7 @@ public:
 
   class MockPieceStorage2 : public MockPieceStorage {
   public:
-    virtual bool hasPiece(int index) {
+    virtual bool hasPiece(size_t index) {
       return index == 1;
     }
   };
diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc
index 707ee718..97504f57 100644
--- a/test/DefaultBtMessageDispatcherTest.cc
+++ b/test/DefaultBtMessageDispatcherTest.cc
@@ -111,7 +111,7 @@ public:
   private:
     SharedHandle<Piece> piece;
   public:
-    virtual SharedHandle<Piece> getPiece(int index) {
+    virtual SharedHandle<Piece> getPiece(size_t index) {
       return piece;
     }
 
@@ -281,7 +281,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
   
   SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
-  assert(piece->getMissingUnusedBlockIndex() == 0);
+  size_t index;
+  CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
   pieceStorage->setPiece(piece);
@@ -308,7 +310,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
   slot.setDispatchedTime(0);
 
   SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
-  assert(piece->getMissingUnusedBlockIndex() == 0);
+  size_t index;
+  CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
   pieceStorage->setPiece(piece);
diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc
index f2cfa9cd..6f8458d0 100644
--- a/test/DefaultBtProgressInfoFileTest.cc
+++ b/test/DefaultBtProgressInfoFileTest.cc
@@ -110,22 +110,22 @@ void DefaultBtProgressInfoFileTest::testLoad()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)2,
+  CPPUNIT_ASSERT_EQUAL((size_t)2,
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
   std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
   SharedHandle<Piece> piece1 = inFlightPieces[0];
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
   CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
   SharedHandle<Piece> piece2 = inFlightPieces[1];
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
 }
 
 void DefaultBtProgressInfoFileTest::testLoad_nonBt()
@@ -146,22 +146,22 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)2,
+  CPPUNIT_ASSERT_EQUAL((size_t)2,
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
   std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
   SharedHandle<Piece> piece1 = inFlightPieces[0];
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
   CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
   SharedHandle<Piece> piece2 = inFlightPieces[1];
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
 
 }
 
@@ -184,7 +184,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)0,
+  CPPUNIT_ASSERT_EQUAL((size_t)0,
 		       _pieceStorage->countInFlightPiece());
 }
 
@@ -224,47 +224,47 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
   in.read((char*)extension, sizeof(extension));
   CPPUNIT_ASSERT_EQUAL(std::string("00000000"), Util::toHex(extension, sizeof(extension)));
 
-  int32_t infoHashLength;
+  uint32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, infoHashLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)0, infoHashLength);
 
-  int32_t pieceLength;
+  uint32_t pieceLength;
   in.read((char*)&pieceLength, sizeof(pieceLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength);
-
-  int64_t totalLength;
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
+  
+  uint64_t totalLength;
   in.read((char*)&totalLength, sizeof(totalLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
 
-  int64_t uploadLength;
+  uint64_t uploadLength;
   in.read((char*)&uploadLength, sizeof(uploadLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, uploadLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)0, uploadLength);
 
-  int32_t bitfieldLength;
+  uint32_t bitfieldLength;
   in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
-  int32_t numInFlightPiece;
+  uint32_t numInFlightPiece;
   in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
 
   // piece index 1
-  int32_t index1;
+  uint32_t index1;
   in.read((char*)&index1, sizeof(index1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, index1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
 
-  int32_t pieceLength1;
+  uint32_t pieceLength1;
   in.read((char*)&pieceLength1, sizeof(pieceLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
 
-  int32_t pieceBitfieldLength1;
+  uint32_t pieceBitfieldLength1;
   in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@@ -272,13 +272,13 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
-  int32_t index2;
+  uint32_t index2;
   in.read((char*)&index2, sizeof(index2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, index2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
 
-  int32_t pieceLength2;
+  uint32_t pieceLength2;
   in.read((char*)&pieceLength2, sizeof(pieceLength2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
 
 }
 
@@ -321,52 +321,52 @@ void DefaultBtProgressInfoFileTest::testSave()
   in.read((char*)extension, sizeof(extension));
   CPPUNIT_ASSERT_EQUAL(std::string("00000001"), Util::toHex(extension, sizeof(extension)));
 
-  int32_t infoHashLength;
+  uint32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)20, infoHashLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)20, infoHashLength);
 
   unsigned char infoHashRead[20];
   in.read((char*)infoHashRead, sizeof(infoHashRead));
   CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"),
 		       Util::toHex(infoHashRead, sizeof(infoHashRead)));
 
-  int32_t pieceLength;
+  uint32_t pieceLength;
   in.read((char*)&pieceLength, sizeof(pieceLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
 
-  int64_t totalLength;
+  uint64_t totalLength;
   in.read((char*)&totalLength, sizeof(totalLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
 
-  int64_t uploadLength;
+  uint64_t uploadLength;
   in.read((char*)&uploadLength, sizeof(uploadLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)1024, uploadLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)1024, uploadLength);
 
-  int32_t bitfieldLength;
+  uint32_t bitfieldLength;
   in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
-  int32_t numInFlightPiece;
+  uint32_t numInFlightPiece;
   in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
 
   // piece index 1
-  int32_t index1;
+  uint32_t index1;
   in.read((char*)&index1, sizeof(index1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, index1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
 
-  int32_t pieceLength1;
+  uint32_t pieceLength1;
   in.read((char*)&pieceLength1, sizeof(pieceLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
 
-  int32_t pieceBitfieldLength1;
+  uint32_t pieceBitfieldLength1;
   in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@@ -374,13 +374,13 @@ void DefaultBtProgressInfoFileTest::testSave()
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
-  int32_t index2;
+  uint32_t index2;
   in.read((char*)&index2, sizeof(index2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, index2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
 
-  int32_t pieceLength2;
+  uint32_t pieceLength2;
   in.read((char*)&pieceLength2, sizeof(pieceLength2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
 
 
 }
diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc
index b537d8ef..905e4bba 100644
--- a/test/DefaultBtRequestFactoryTest.cc
+++ b/test/DefaultBtRequestFactoryTest.cc
@@ -39,10 +39,10 @@ public:
 
   class MockBtRequestMessage : public MockBtMessage {
   public:
-    int index;
-    int blockIndex;
+    size_t index;
+    size_t blockIndex;
 
-    MockBtRequestMessage(int index, int blockIndex):index(index), blockIndex(blockIndex) {}
+    MockBtRequestMessage(size_t index, size_t blockIndex):index(index), blockIndex(blockIndex) {}
   };
   
   typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle;
@@ -126,7 +126,7 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
   CPPUNIT_ASSERT_EQUAL((int32_t)2, btRequestFactory->countTargetPiece());
   btRequestFactory->removeCompletedPiece();
   CPPUNIT_ASSERT_EQUAL((int32_t)1, btRequestFactory->countTargetPiece());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, btRequestFactory->getTargetPieces().front()->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, btRequestFactory->getTargetPieces().front()->getIndex());
 }
 
 void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
@@ -141,16 +141,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
   std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, btRequestFactory->createRequestMessages(3).size());
 }
@@ -173,16 +173,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
   std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
 }
 
 void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc
index bc268731..082d6d29 100644
--- a/test/DefaultPieceStorageTest.cc
+++ b/test/DefaultPieceStorageTest.cc
@@ -71,8 +71,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
 void DefaultPieceStorageTest::testGetTotalLength() {
   DefaultPieceStorage pss(btContext, option);
 
-  CPPUNIT_ASSERT_EQUAL((long long int)384,
-		       pss.getTotalLength());
+  CPPUNIT_ASSERT_EQUAL(384ULL, pss.getTotalLength());
 }
 
 void DefaultPieceStorageTest::testGetMissingPiece() {
@@ -126,26 +125,23 @@ void DefaultPieceStorageTest::testCompletePiece() {
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
 		       piece->toString());
 
-  CPPUNIT_ASSERT_EQUAL((int64_t)0,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(0ULL, pss.getCompletedLength());
 
   pss.completePiece(piece);
 
-  CPPUNIT_ASSERT_EQUAL((int64_t)128,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(128ULL, pss.getCompletedLength());
 
   SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer);
   incompletePiece->completeBlock(0);
-  CPPUNIT_ASSERT_EQUAL((int64_t)256,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(256ULL, pss.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetPiece() {
   DefaultPieceStorage pss(btContext, option);
   
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete());
 }
 
@@ -155,9 +151,9 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
   piece->completeBlock(0);
   pss.addUsedPiece(piece);
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceGot->countCompleteBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceGot->countCompleteBlock());
 }
 
 void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
@@ -165,15 +161,15 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
   SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
   pss.completePiece(piece);
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete());
 }
 
 void DefaultPieceStorageTest::testCancelPiece()
 {
-  int32_t pieceLength = 256*1024;
-  int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
+  size_t pieceLength = 256*1024;
+  uint64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
   std::deque<std::string> uris1;
   uris1.push_back("http://localhost/src/file1.txt");
   SharedHandle<FileEntry> file1 = new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/);
@@ -197,8 +193,8 @@ void DefaultPieceStorageTest::testCancelPiece()
 
 void DefaultPieceStorageTest::testMarkPiecesDone()
 {
-  int32_t pieceLength = 256*1024;
-  int64_t totalLength = 4*1024*1024;
+  size_t pieceLength = 256*1024;
+  uint64_t totalLength = 4*1024*1024;
   SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
@@ -207,17 +203,17 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
 
   ps.markPiecesDone(pieceLength*10+16*1024*2+1);
 
-  for(int32_t i = 0; i < 10; ++i) {
+  for(size_t i = 0; i < 10; ++i) {
     CPPUNIT_ASSERT(ps.hasPiece(i));
   }
-  for(int32_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
+  for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
     CPPUNIT_ASSERT(!ps.hasPiece(i));
   }
-  CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((uint64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
 
   ps.markPiecesDone(totalLength);
 
-  for(int32_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
+  for(size_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
     CPPUNIT_ASSERT(ps.hasPiece(i));
   }
 }
diff --git a/test/GrowSegmentTest.cc b/test/GrowSegmentTest.cc
index 6f8fdcb8..4ecefbd8 100644
--- a/test/GrowSegmentTest.cc
+++ b/test/GrowSegmentTest.cc
@@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
   GrowSegment segment(new Piece());
   segment.updateWrittenLength(32*1024);
   
-  CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite());
+  CPPUNIT_ASSERT_EQUAL((off_t)32*1024, segment.getPositionToWrite());
   CPPUNIT_ASSERT(!segment.complete());
   CPPUNIT_ASSERT(segment.getPiece()->pieceComplete());
 }
@@ -36,9 +36,9 @@ void GrowSegmentTest::testClear()
 {
   GrowSegment segment(new Piece());
   segment.updateWrittenLength(32*1024);
-  CPPUNIT_ASSERT_EQUAL((int32_t)32*1024, segment.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)32*1024, segment.getWrittenLength());
   segment.clear();
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment.getWrittenLength());  
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment.getWrittenLength());  
 }
 
 } // namespace aria2
diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h
index 8987a0a9..9307675b 100644
--- a/test/MockBtRequestFactory.h
+++ b/test/MockBtRequestFactory.h
@@ -22,10 +22,10 @@ public:
   virtual void doChokedAction() {}
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessages(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
+  createRequestMessages(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessagesOnEndGame(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
+  createRequestMessagesOnEndGame(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 };
 
 } // namespace aria2
diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h
index be3c43f1..2f5a7434 100644
--- a/test/MockPieceStorage.h
+++ b/test/MockPieceStorage.h
@@ -11,15 +11,15 @@ namespace aria2 {
 
 class MockPieceStorage : public PieceStorage {
 private:
-  int64_t totalLength;
-  int64_t filteredTotalLength;
-  int64_t completedLength;
-  int64_t filteredCompletedLength;
+  uint64_t totalLength;
+  uint64_t filteredTotalLength;
+  uint64_t completedLength;
+  uint64_t filteredCompletedLength;
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
   SharedHandle<DiskAdaptor> diskAdaptor;
-  std::deque<int32_t> pieceLengthList;
+  std::deque<size_t> pieceLengthList;
   std::deque<SharedHandle<Piece> > inFlightPieces;
   bool _allDownloadFinished;
 public:
@@ -52,21 +52,21 @@ public:
     return new Piece();
   }
 
-  virtual SharedHandle<Piece> getMissingPiece(int32_t index)
+  virtual SharedHandle<Piece> getMissingPiece(size_t index)
   {
     return new Piece();
   }
 
-  virtual bool isPieceUsed(int32_t index)
+  virtual bool isPieceUsed(size_t index)
   {
     return false;
   }
 
-  virtual void markPieceMissing(int32_t index) {}
+  virtual void markPieceMissing(size_t index) {}
 
-  virtual void markPiecesDone(int64_t) {}
+  virtual void markPiecesDone(uint64_t) {}
 
-  virtual SharedHandle<Piece> getPiece(int32_t index) {
+  virtual SharedHandle<Piece> getPiece(size_t index) {
     return new Piece();
   }
 
@@ -74,39 +74,39 @@ public:
 
   virtual void cancelPiece(const SharedHandle<Piece>& piece) {}
 
-  virtual bool hasPiece(int32_t index) {
+  virtual bool hasPiece(size_t index) {
     return false;
   }
 
-  virtual int64_t getTotalLength() {
+  virtual uint64_t getTotalLength() {
     return totalLength;
   }
 
-  void setTotalLength(int64_t totalLength) {
+  void setTotalLength(uint64_t totalLength) {
     this->totalLength = totalLength;
   }
 
-  virtual int64_t getFilteredTotalLength() {
+  virtual uint64_t getFilteredTotalLength() {
     return filteredTotalLength;
   }
 
-  void setFilteredTotalLength(int64_t totalLength) {
+  void setFilteredTotalLength(uint64_t totalLength) {
     this->filteredTotalLength = totalLength;
   }
 
-  virtual int64_t getCompletedLength() {
+  virtual uint64_t getCompletedLength() {
     return completedLength;
   }
 
-  void setCompletedLength(int64_t completedLength) {
+  void setCompletedLength(uint64_t completedLength) {
     this->completedLength = completedLength;
   }
 
-  virtual int64_t getFilteredCompletedLength() {
+  virtual uint64_t getFilteredCompletedLength() {
     return filteredCompletedLength;
   }
 
-  void setFilteredCompletedLength(int64_t completedLength) {
+  void setFilteredCompletedLength(uint64_t completedLength) {
     this->filteredCompletedLength = completedLength;
   }
   
@@ -136,11 +136,11 @@ public:
   }
 
   virtual void setBitfield(const unsigned char* bitfield,
-			   int32_t bitfieldLength) {
+			   size_t bitfieldLength) {
     bitfieldMan->setBitfield(bitfield, bitfieldLength);
   }
   
-  virtual int32_t getBitfieldLength() {
+  virtual size_t getBitfieldLength() {
     return bitfieldMan->getBitfieldLength();
   }
 
@@ -174,22 +174,22 @@ public:
     this->diskAdaptor = adaptor;
   }
   
-  virtual int32_t getPieceLength(int32_t index) {
+  virtual size_t getPieceLength(size_t index) {
     return pieceLengthList.at(index);
   }
 
-  void addPieceLengthList(int32_t length) {
+  void addPieceLengthList(size_t length) {
     pieceLengthList.push_back(length);
   }
 
-  virtual void advertisePiece(int32_t cuid, int32_t index) {}
+  virtual void advertisePiece(int32_t cuid, size_t index) {}
 
-  virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid,
-							const Time& lastCheckTime) {
-    return std::deque<int32_t>();
+  virtual std::deque<size_t> getAdvertisedPieceIndexes(int32_t myCuid,
+						       const Time& lastCheckTime) {
+    return std::deque<size_t>();
   }
 
-  virtual void removeAdvertisedPiece(int32_t elapsed) {}
+  virtual void removeAdvertisedPiece(time_t elapsed) {}
 
   virtual void markAllPiecesDone() {}
 
@@ -198,7 +198,7 @@ public:
     std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
   }
 
-  virtual int32_t countInFlightPiece()
+  virtual size_t countInFlightPiece()
   {
     return inFlightPieces.size();
   }
diff --git a/test/PieceTest.cc b/test/PieceTest.cc
index 516f3f31..52b461ec 100644
--- a/test/PieceTest.cc
+++ b/test/PieceTest.cc
@@ -42,7 +42,7 @@ void PieceTest::testGetCompletedLength()
   p.completeBlock(9);
   p.completeBlock(10); // <-- 100 bytes
   
-  CPPUNIT_ASSERT_EQUAL(blockLength*3+100, p.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)blockLength*3+100, p.getCompletedLength());
 }
 
 } // namespace aria2
diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc
index 580d2019..495d98e5 100644
--- a/test/SegmentManTest.cc
+++ b/test/SegmentManTest.cc
@@ -43,10 +43,10 @@ void SegmentManTest::testNullBitfield()
 
   SharedHandle<Segment> segment = segmentMan.getSegment(1);
   CPPUNIT_ASSERT(!segment.isNull());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getSegmentLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getSegmentLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getWrittenLength());
 
   SharedHandle<Segment> segment2 = segmentMan.getSegment(2);
   CPPUNIT_ASSERT(segment2.isNull());
@@ -58,8 +58,8 @@ void SegmentManTest::testNullBitfield()
 void SegmentManTest::testCompleteSegment()
 {
   Option op;
-  int32_t pieceLength = 1024*1024;
-  int64_t totalLength = 64*1024*1024;
+  size_t pieceLength = 1024*1024;
+  uint64_t totalLength = 64*1024*1024;
   SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
@@ -78,8 +78,8 @@ void SegmentManTest::testCompleteSegment()
   
   std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
-  CPPUNIT_ASSERT_EQUAL(0, segments[0]->getIndex());
-  CPPUNIT_ASSERT_EQUAL(2, segments[1]->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, segments[1]->getIndex());
 }
 
 void SegmentManTest::testMarkPieceDone_usedSegment()
diff --git a/test/SegmentTest.cc b/test/SegmentTest.cc
index 1d500e93..4644a648 100644
--- a/test/SegmentTest.cc
+++ b/test/SegmentTest.cc
@@ -32,7 +32,7 @@ void SegmentTest::testUpdateWrittenLength()
 {
   SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
 
   s.updateWrittenLength(16*1024);
   CPPUNIT_ASSERT(p->hasBlock(0));
@@ -49,7 +49,7 @@ void SegmentTest::testUpdateWrittenLength_overflow()
 
   s.updateWrittenLength(16*1024*11);
   CPPUNIT_ASSERT(p->pieceComplete());
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
 }
 
 void SegmentTest::testUpdateWrittenLength_lastPiece()
@@ -77,11 +77,11 @@ void SegmentTest::testClear()
   SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
   s.updateWrittenLength(16*1024*11);
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024*10, s.getWrittenLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024*10, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
   s.clear();
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getOverflowLength());
 }
 
 } // namespace aria2