Replaced uint64_t with off_t or int64_t.

Since off_t is int64_t with LFS, we cannot take advantage of extra
capacity of uint64_t.

21 files changed, 105 insertions, 127 deletions

diff --git a/test/BitfieldManTest.cc b/test/BitfieldManTest.cc
index 1bd88eef..72e91d05 100644
--- a/test/BitfieldManTest.cc
+++ b/test/BitfieldManTest.cc
@@ -221,7 +221,7 @@ void BitfieldManTest::testFilter()
   for(size_t i = 0; i < A2_ARRAY_LEN(ans); ++i) {
     CPPUNIT_ASSERT_EQUAL(ans[i], out[i]);
   }
-  CPPUNIT_ASSERT_EQUAL((uint64_t)12ULL, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)12ULL, btman.getFilteredTotalLength());
 
   // test offset=5, length=2
   out.clear();
@@ -235,13 +235,13 @@ void BitfieldManTest::testFilter()
   CPPUNIT_ASSERT_EQUAL((size_t)3, out[1]);
   btman.setBit(2);
   btman.setBit(3);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4ULL, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)4ULL, btman.getFilteredTotalLength());
   CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
 
   BitfieldMan btman2(2, 31);
   btman2.addFilter(0, 31);
   btman2.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((uint64_t)31ULL, btman2.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)31ULL, btman2.getFilteredTotalLength());
 }
 
 void BitfieldManTest::testAddFilter_zeroLength()
@@ -453,27 +453,27 @@ void BitfieldManTest::testGetOffsetCompletedLength()
 {
   BitfieldMan bt(1024, 1024*20);
   // 00000|00000|00000|00000
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(0, 1024));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(0, 0));
+  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 1024));
+  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 0));
   for(size_t i = 2; i <= 4; ++i) {
     bt.setBit(i);
   }
   // 00111|00000|00000|00000
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3072, bt.getOffsetCompletedLength(2048, 3072));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3071, bt.getOffsetCompletedLength(2047, 3072));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3071, bt.getOffsetCompletedLength(2049, 3072));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(2048, 0));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)1, bt.getOffsetCompletedLength(2048, 1));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(2047, 1));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3072, bt.getOffsetCompletedLength(0, 1024*20));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3072,
+  CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(2048, 3072));
+  CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2047, 3072));
+  CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2049, 3072));
+  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2048, 0));
+  CPPUNIT_ASSERT_EQUAL((off_t)1, bt.getOffsetCompletedLength(2048, 1));
+  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2047, 1));
+  CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(0, 1024*20));
+  CPPUNIT_ASSERT_EQUAL((off_t)3072,
                        bt.getOffsetCompletedLength(0, 1024*20+10));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(1024*20, 1));
+  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(1024*20, 1));
 }
 
 void BitfieldManTest::testGetMissingUnusedLength()
 {
-  uint64_t totalLength = 1024*10+10;
+  off_t totalLength = 1024*10+10;
   size_t blockLength = 1024;
 
   BitfieldMan bf(blockLength, totalLength);
@@ -482,30 +482,30 @@ void BitfieldManTest::testGetMissingUnusedLength()
   CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
 
   // from index 10 and all blocks are unused and not acquired.
-  CPPUNIT_ASSERT_EQUAL((uint64_t)10ULL, bf.getMissingUnusedLength(10));
+  CPPUNIT_ASSERT_EQUAL((off_t)10ULL, bf.getMissingUnusedLength(10));
 
   // from index 11
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, bf.getMissingUnusedLength(11));
+  CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(11));
 
   // from index 12
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, bf.getMissingUnusedLength(12));
+  CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(12));
 
   // from index 0 and 5th block is used.
   bf.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)5ULL*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getMissingUnusedLength(0));
 
   // from index 0 and 4th block is acquired.
   bf.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4ULL*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL((off_t)(4LL*blockLength), bf.getMissingUnusedLength(0));
 
   // from index 1
-  CPPUNIT_ASSERT_EQUAL((uint64_t)3ULL*blockLength, bf.getMissingUnusedLength(1));
+  CPPUNIT_ASSERT_EQUAL((off_t)(3LL*blockLength), bf.getMissingUnusedLength(1));
 }
 
 void BitfieldManTest::testSetBitRange()
 {
   size_t blockLength = 1024*1024;
-  uint64_t totalLength = 10*blockLength;
+  off_t totalLength = 10*blockLength;
 
   BitfieldMan bf(blockLength, totalLength);
 
@@ -517,13 +517,13 @@ void BitfieldManTest::testSetBitRange()
   for(size_t i = 5; i < 10; ++i) {
     CPPUNIT_ASSERT(!bf.isBitSet(i));
   }
-  CPPUNIT_ASSERT_EQUAL((uint64_t)5ULL*blockLength, bf.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getCompletedLength());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes_noarg()
 {
   size_t blockLength = 16*1024;
-  uint64_t totalLength = 1024*1024;
+  off_t totalLength = 1024*1024;
   size_t nbits = (totalLength+blockLength-1)/blockLength;
   BitfieldMan bf(blockLength, totalLength);
   unsigned char misbitfield[8];
@@ -542,7 +542,7 @@ void BitfieldManTest::testGetAllMissingIndexes_noarg()
 void BitfieldManTest::testGetAllMissingIndexes_checkLastByte()
 {
   size_t blockLength = 16*1024;
-  uint64_t totalLength = blockLength*2;
+  off_t totalLength = blockLength*2;
   size_t nbits = (totalLength+blockLength-1)/blockLength;
   BitfieldMan bf(blockLength, totalLength);
   unsigned char misbitfield[1];
@@ -555,7 +555,7 @@ void BitfieldManTest::testGetAllMissingIndexes_checkLastByte()
 void BitfieldManTest::testGetAllMissingIndexes()
 {
   size_t blockLength = 16*1024;
-  uint64_t totalLength = 1024*1024;
+  off_t totalLength = 1024*1024;
   size_t nbits = (totalLength+blockLength-1)/blockLength;
   BitfieldMan bf(blockLength, totalLength);
   BitfieldMan peerBf(blockLength, totalLength);
@@ -581,7 +581,7 @@ void BitfieldManTest::testGetAllMissingIndexes()
 void BitfieldManTest::testGetAllMissingUnusedIndexes()
 {
   size_t blockLength = 16*1024;
-  uint64_t totalLength = 1024*1024;
+  off_t totalLength = 1024*1024;
   size_t nbits = (totalLength+blockLength-1)/blockLength;
   BitfieldMan bf(blockLength, totalLength);
   BitfieldMan peerBf(blockLength, totalLength);
diff --git a/test/BittorrentHelperTest.cc b/test/BittorrentHelperTest.cc
index 64428600..247d2113 100644
--- a/test/BittorrentHelperTest.cc
+++ b/test/BittorrentHelperTest.cc
@@ -205,14 +205,14 @@ void BittorrentHelperTest::testGetTotalLength() {
   SharedHandle<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetTotalLengthSingle() {
   SharedHandle<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetFileModeMulti() {
diff --git a/test/ByteArrayDiskWriterTest.cc b/test/ByteArrayDiskWriterTest.cc
index 002367c4..6630f970 100644
--- a/test/ByteArrayDiskWriterTest.cc
+++ b/test/ByteArrayDiskWriterTest.cc
@@ -43,7 +43,7 @@ void ByteArrayDiskWriterTest::testWriteAndRead() {
   buf[c] = '\0';
 
   CPPUNIT_ASSERT_EQUAL(std::string("ello World !!"), std::string(buf));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)14, bw.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)14, bw.size());
 }
 
 void ByteArrayDiskWriterTest::testWriteAndRead2() {
@@ -59,7 +59,7 @@ void ByteArrayDiskWriterTest::testWriteAndRead2() {
   buf[c] = '\0';
 
   CPPUNIT_ASSERT_EQUAL(std::string("Hello From Mars"), std::string(buf));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)15, bw.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)15, bw.size());
 }
 
 } // namespace aria2
diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc
index 50dad43a..23f75ed8 100644
--- a/test/DefaultBtProgressInfoFileTest.cc
+++ b/test/DefaultBtProgressInfoFileTest.cc
@@ -53,7 +53,7 @@ private:
   SharedHandle<Option> option_;
   SharedHandle<BitfieldMan> bitfield_;
 public:   
-  void initializeMembers(int32_t pieceLength, int64_t totalLength)
+  void initializeMembers(int32_t pieceLength, off_t totalLength)
   {
     option_.reset(new Option());
     option_->put(PREF_DIR, A2_TEST_OUT_DIR);
@@ -126,10 +126,10 @@ void DefaultBtProgressInfoFileTest::testLoad_compat()
   // check the contents of objects
 
   // total length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength());
 
   // upload length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup());
+  CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
 
   // bitfield
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@@ -175,10 +175,10 @@ void DefaultBtProgressInfoFileTest::testLoad()
   // check the contents of objects
 
   // total length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength());
 
   // upload length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup());
+  CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
 
   // bitfield
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@@ -343,7 +343,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
   // check the contents of objects
 
   // total length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength());
 
   // bitfield
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@@ -388,7 +388,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
   // check the contents of objects
 
   // total length
-  CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength());
 
   // bitfield
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
diff --git a/test/DefaultDiskWriterTest.cc b/test/DefaultDiskWriterTest.cc
index 2e1733c5..19b05936 100644
--- a/test/DefaultDiskWriterTest.cc
+++ b/test/DefaultDiskWriterTest.cc
@@ -25,7 +25,7 @@ void DefaultDiskWriterTest::testSize()
   DefaultDiskWriter dw(A2_TEST_DIR"/4096chunk.txt");
   dw.enableReadOnly();
   dw.openExistingFile();
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4096ULL, dw.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)4096LL, dw.size());
 }
 
 } // namespace aria2
diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc
index 054d2598..f383c457 100644
--- a/test/DefaultPieceStorageTest.cc
+++ b/test/DefaultPieceStorageTest.cc
@@ -80,7 +80,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
 void DefaultPieceStorageTest::testGetTotalLength() {
   DefaultPieceStorage pss(dctx_, option_.get());
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, pss.getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)384LL, pss.getTotalLength());
 }
 
 void DefaultPieceStorageTest::testGetMissingPiece() {
@@ -220,15 +220,15 @@ void DefaultPieceStorageTest::testCompletePiece() {
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
                        piece->toString());
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0LL, pss.getCompletedLength());
 
   pss.completePiece(piece);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)128ULL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)128LL, pss.getCompletedLength());
 
   SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer, 1);
   incompletePiece->completeBlock(0);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)256ULL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)256LL, pss.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetPiece() {
@@ -264,7 +264,7 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
 void DefaultPieceStorageTest::testCancelPiece()
 {
   size_t pieceLength = 256*1024;
-  uint64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
+  off_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*/));
@@ -289,7 +289,7 @@ void DefaultPieceStorageTest::testCancelPiece()
 void DefaultPieceStorageTest::testMarkPiecesDone()
 {
   size_t pieceLength = 256*1024;
-  uint64_t totalLength = 4*1024*1024;
+  off_t totalLength = 4*1024*1024;
   SharedHandle<DownloadContext> dctx
     (new DownloadContext(pieceLength, totalLength));
 
@@ -303,7 +303,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
   for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
     CPPUNIT_ASSERT(!ps.hasPiece(i));
   }
-  CPPUNIT_ASSERT_EQUAL((uint64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
 
   ps.markPiecesDone(totalLength);
 
@@ -312,7 +312,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
   }
 
   ps.markPiecesDone(0);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetCompletedLength()
@@ -322,10 +322,10 @@ void DefaultPieceStorageTest::testGetCompletedLength()
   
   DefaultPieceStorage ps(dctx, option_.get());
   
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
 
   ps.markPiecesDone(250*1024*1024);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)250*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)250*1024*1024, ps.getCompletedLength());
 
   std::vector<SharedHandle<Piece> > inFlightPieces;
   for(int i = 0; i < 2; ++i) {
@@ -338,11 +338,11 @@ void DefaultPieceStorageTest::testGetCompletedLength()
   }
   ps.addInFlightPiece(inFlightPieces);
   
-  CPPUNIT_ASSERT_EQUAL((uint64_t)251*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)251*1024*1024, ps.getCompletedLength());
 
   ps.markPiecesDone(256*1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)256*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)256*1024*1024, ps.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetNextUsedIndex()
diff --git a/test/DirectDiskAdaptorTest.cc b/test/DirectDiskAdaptorTest.cc
index 164c66d4..5745c8d4 100644
--- a/test/DirectDiskAdaptorTest.cc
+++ b/test/DirectDiskAdaptorTest.cc
@@ -46,7 +46,7 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
 
   adaptor.cutTrailingGarbage();
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)entry->getLength(),
+  CPPUNIT_ASSERT_EQUAL((off_t)entry->getLength(),
                        File(entry->getPath()).size());
 }
 
diff --git a/test/FtpConnectionTest.cc b/test/FtpConnectionTest.cc
index 7675ac30..501427bc 100644
--- a/test/FtpConnectionTest.cc
+++ b/test/FtpConnectionTest.cc
@@ -287,9 +287,9 @@ void FtpConnectionTest::testReceiveSizeResponse()
 {
   serverSocket_->writeData("213 4294967296\r\n");
   waitRead(clientSocket_);
-  uint64_t size;
+  off_t size;
   CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveSizeResponse(size));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296LL, size);
+  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, size);
 }
 
 void FtpConnectionTest::testSendRetr()
diff --git a/test/HandshakeExtensionMessageTest.cc b/test/HandshakeExtensionMessageTest.cc
index 52eb888d..4d7941bf 100644
--- a/test/HandshakeExtensionMessageTest.cc
+++ b/test/HandshakeExtensionMessageTest.cc
@@ -119,7 +119,7 @@ void HandshakeExtensionMessageTest::testDoReceivedAction()
   CPPUNIT_ASSERT_EQUAL((uint8_t)2, peer->getExtensionMessageID("a2_dht"));
   CPPUNIT_ASSERT(peer->isSeeder());
   CPPUNIT_ASSERT_EQUAL((size_t)1024, attrs->metadataSize);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)1024, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)1024, dctx->getTotalLength());
   CPPUNIT_ASSERT(dctx->knowsTotalLength());
 
   // See Peer is not marked as seeder if !attrs->metadata.empty()
diff --git a/test/HttpHeaderProcessorTest.cc b/test/HttpHeaderProcessorTest.cc
index 162f59aa..ad41b955 100644
--- a/test/HttpHeaderProcessorTest.cc
+++ b/test/HttpHeaderProcessorTest.cc
@@ -117,8 +117,8 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader()
                        header->find("date"));
   CPPUNIT_ASSERT_EQUAL(std::string("Apache/2.2.3 (Debian)"),
                        header->find("server"));
-  CPPUNIT_ASSERT_EQUAL((uint64_t)9187ULL,
-                       header->findAsULLInt("content-length"));
+  CPPUNIT_ASSERT_EQUAL((int64_t)9187LL,
+                       header->findAsLLInt("content-length"));
   CPPUNIT_ASSERT_EQUAL(std::string("text/html; charset=UTF-8"),
                        header->find("content-type"));
   CPPUNIT_ASSERT(!header->defined("entity"));
diff --git a/test/HttpHeaderTest.cc b/test/HttpHeaderTest.cc
index fc31cf04..690f3818 100644
--- a/test/HttpHeaderTest.cc
+++ b/test/HttpHeaderTest.cc
@@ -37,7 +37,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -48,7 +48,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -58,7 +58,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -68,7 +68,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -78,7 +78,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -88,7 +88,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -98,7 +98,7 @@ void HttpHeaderTest::testGetRange()
 
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
     CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
diff --git a/test/HttpResponseTest.cc b/test/HttpResponseTest.cc
index 482ba66c..a5c8d7ed 100644
--- a/test/HttpResponseTest.cc
+++ b/test/HttpResponseTest.cc
@@ -101,7 +101,7 @@ void HttpResponseTest::testGetContentLength_null()
 {
   HttpResponse httpResponse;
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, httpResponse.getContentLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpResponse.getContentLength());
 }
 
 void HttpResponseTest::testGetContentLength_contentLength()
@@ -113,7 +113,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296ULL, httpResponse.getContentLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getContentLength());
 }
 
 void HttpResponseTest::testGetEntityLength()
@@ -125,11 +125,11 @@ void HttpResponseTest::testGetEntityLength()
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296ULL, httpResponse.getEntityLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getEntityLength());
 
   httpHeader->put("content-range", "bytes 1-4294967296/4294967297");
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)4294967297ULL, httpResponse.getEntityLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)4294967297LL, httpResponse.getEntityLength());
 
 }
 
diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc
index a69df183..f38339a6 100644
--- a/test/Metalink2RequestGroupTest.cc
+++ b/test/Metalink2RequestGroupTest.cc
@@ -58,7 +58,7 @@ void Metalink2RequestGroupTest::testGenerate()
     const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, dctx->getTotalLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0LL, dctx->getTotalLength());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
     CPPUNIT_ASSERT_EQUAL
diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc
index 1b1747b0..dea69f7d 100644
--- a/test/MetalinkParserControllerTest.cc
+++ b/test/MetalinkParserControllerTest.cc
@@ -68,7 +68,7 @@ void MetalinkParserControllerTest::testEntryTransaction()
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
     SharedHandle<MetalinkEntry> e = m->getEntries().front();
     CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)(1024*1024ULL), e->file->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)(1024*1024LL), e->file->getLength());
     CPPUNIT_ASSERT_EQUAL((off_t)0, e->file->getOffset());
     CPPUNIT_ASSERT_EQUAL(std::string("1.0"), e->version);
     CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->languages[0]);
diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc
index 26c9492f..7110a3b9 100644
--- a/test/MetalinkProcessorTest.cc
+++ b/test/MetalinkProcessorTest.cc
@@ -89,7 +89,7 @@ void MetalinkProcessorTest::testParseFileV4()
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
   e = m->getEntries()[0];
   CPPUNIT_ASSERT_EQUAL(std::string("example.ext"), e->getPath());
-  CPPUNIT_ASSERT_EQUAL((uint64_t)786430LL, e->getLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)786430LL, e->getLength());
   CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
   CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
@@ -500,7 +500,7 @@ void MetalinkProcessorTest::testParseFile()
 
     SharedHandle<MetalinkEntry> entry1 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, entry1->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0LL, entry1->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version);
     CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entry1->languages[0]);
     CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entry1->oses[0]);
@@ -550,7 +550,7 @@ void MetalinkProcessorTest::testParseFile()
 
     SharedHandle<MetalinkEntry> entry2 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)345689ULL, entry2->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)345689LL, entry2->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version);
     CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entry2->languages[0]);
     CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entry2->oses[0]);
@@ -697,7 +697,7 @@ void MetalinkProcessorTest::testBadSize()
       m->getEntries().begin();
     SharedHandle<MetalinkEntry> e = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)0LL, e->getLength());
     CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), e->version);
     CPPUNIT_ASSERT_EQUAL(std::string("en-US"), e->languages[0]);
     CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), e->oses[0]);
@@ -728,7 +728,7 @@ void MetalinkProcessorTest::testBadMaxConn()
     std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
       m->getEntries().begin();
     SharedHandle<MetalinkEntry> e = *entryItr;
-    CPPUNIT_ASSERT_EQUAL((uint64_t)43743838ULL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)43743838LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
@@ -1008,7 +1008,7 @@ void MetalinkProcessorTest::testLargeFileSize()
   try {
     SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
     SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
@@ -1032,7 +1032,7 @@ void MetalinkProcessorTest::testXmlPrefixV3()
     SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
     SharedHandle<MetalinkEntry> e = m->getEntries()[0];
-    CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h
index 8b1cb631..36e64b00 100644
--- a/test/MockPieceStorage.h
+++ b/test/MockPieceStorage.h
@@ -13,10 +13,10 @@ namespace aria2 {
 
 class MockPieceStorage : public PieceStorage {
 private:
-  uint64_t totalLength;
-  uint64_t filteredTotalLength;
-  uint64_t completedLength;
-  uint64_t filteredCompletedLength;
+  off_t totalLength;
+  off_t filteredTotalLength;
+  off_t completedLength;
+  off_t filteredCompletedLength;
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
@@ -117,7 +117,7 @@ public:
 
   virtual void markPieceMissing(size_t index) {}
 
-  virtual void markPiecesDone(uint64_t) {}
+  virtual void markPiecesDone(off_t) {}
 
   virtual SharedHandle<Piece> getPiece(size_t index) {
     return SharedHandle<Piece>(new Piece());
@@ -131,35 +131,35 @@ public:
     return false;
   }
 
-  virtual uint64_t getTotalLength() {
+  virtual off_t getTotalLength() {
     return totalLength;
   }
 
-  void setTotalLength(uint64_t totalLength) {
+  void setTotalLength(off_t totalLength) {
     this->totalLength = totalLength;
   }
 
-  virtual uint64_t getFilteredTotalLength() {
+  virtual off_t getFilteredTotalLength() {
     return filteredTotalLength;
   }
 
-  void setFilteredTotalLength(uint64_t totalLength) {
+  void setFilteredTotalLength(off_t totalLength) {
     this->filteredTotalLength = totalLength;
   }
 
-  virtual uint64_t getCompletedLength() {
+  virtual off_t getCompletedLength() {
     return completedLength;
   }
 
-  void setCompletedLength(uint64_t completedLength) {
+  void setCompletedLength(off_t completedLength) {
     this->completedLength = completedLength;
   }
 
-  virtual uint64_t getFilteredCompletedLength() {
+  virtual off_t getFilteredCompletedLength() {
     return filteredCompletedLength;
   }
 
-  void setFilteredCompletedLength(uint64_t completedLength) {
+  void setFilteredCompletedLength(off_t completedLength) {
     this->filteredCompletedLength = completedLength;
   }
   
diff --git a/test/MultiDiskAdaptorTest.cc b/test/MultiDiskAdaptorTest.cc
index 7a7ae1e5..bf4473b9 100644
--- a/test/MultiDiskAdaptorTest.cc
+++ b/test/MultiDiskAdaptorTest.cc
@@ -386,9 +386,9 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
 
   adaptor.cutTrailingGarbage();
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)256,
+  CPPUNIT_ASSERT_EQUAL((off_t)256,
                        File(entries[0]->getPath()).size());
-  CPPUNIT_ASSERT_EQUAL((uint64_t)512,
+  CPPUNIT_ASSERT_EQUAL((off_t)512,
                        File(entries[1]->getPath()).size());
 }
 
@@ -413,7 +413,7 @@ void MultiDiskAdaptorTest::testSize()
   
   adaptor.openFile();
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)2, adaptor.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)2, adaptor.size());
 }
 
 void MultiDiskAdaptorTest::testUtime()
diff --git a/test/MultiFileAllocationIteratorTest.cc b/test/MultiFileAllocationIteratorTest.cc
index 9d5aaf62..03237451 100644
--- a/test/MultiFileAllocationIteratorTest.cc
+++ b/test/MultiFileAllocationIteratorTest.cc
@@ -209,11 +209,11 @@ void MultiFileAllocationIteratorTest::testAllocate()
     while(!itr->finished()) {
       itr->allocateChunk();
     }
-    CPPUNIT_ASSERT_EQUAL((uint64_t)length1, File(fileEntry1->getPath()).size());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)length2, File(fileEntry2->getPath()).size());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)length3, File(fileEntry3->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((off_t)length1, File(fileEntry1->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((off_t)length2, File(fileEntry2->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((off_t)length3, File(fileEntry3->getPath()).size());
     CPPUNIT_ASSERT(!File(fileEntry4->getPath()).isFile());
-    CPPUNIT_ASSERT_EQUAL((uint64_t)length5, File(fileEntry5->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((off_t)length5, File(fileEntry5->getPath()).size());
     CPPUNIT_ASSERT(!File(fileEntry6->getPath()).isFile());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
diff --git a/test/PeerSessionResourceTest.cc b/test/PeerSessionResourceTest.cc
index ff7c2fcf..1ced80ac 100644
--- a/test/PeerSessionResourceTest.cc
+++ b/test/PeerSessionResourceTest.cc
@@ -106,20 +106,20 @@ void PeerSessionResourceTest::testUpdateUploadLength()
 {
   PeerSessionResource res(1024, 1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, res.uploadLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.uploadLength());
   res.updateUploadLength(100);
   res.updateUploadLength(200);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)300ULL, res.uploadLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.uploadLength());
 }
 
 void PeerSessionResourceTest::testUpdateDownloadLength()
 {
   PeerSessionResource res(1024, 1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, res.downloadLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.downloadLength());
   res.updateDownloadLength(100);
   res.updateDownloadLength(200);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)300ULL, res.downloadLength());
+  CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.downloadLength());
 }
 
 void PeerSessionResourceTest::testExtendedMessageEnabled()
diff --git a/test/SingleFileAllocationIteratorTest.cc b/test/SingleFileAllocationIteratorTest.cc
index 04387a19..ace14d9f 100644
--- a/test/SingleFileAllocationIteratorTest.cc
+++ b/test/SingleFileAllocationIteratorTest.cc
@@ -32,11 +32,11 @@ void SingleFileAllocationIteratorTest::testAllocate()
   of.close();
 
   File x(fn);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)10, x.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)10, x.size());
 
   DefaultDiskWriter writer(fn);
-  int64_t offset = 10;
-  int64_t totalLength = 16*1024*2+8*1024;
+  off_t offset = 10;
+  off_t totalLength = 16*1024*2+8*1024;
 
   // we have to open file first.
   writer.openExistingFile();
@@ -47,7 +47,7 @@ void SingleFileAllocationIteratorTest::testAllocate()
     itr.allocateChunk();
   }
   File f(fn);
-  CPPUNIT_ASSERT_EQUAL((uint64_t)40960, f.size());
+  CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size());
 }
 
 } // namespace aria2
diff --git a/test/UtilTest.cc b/test/UtilTest.cc
index 5f3c99b5..cb04d27c 100644
--- a/test/UtilTest.cc
+++ b/test/UtilTest.cc
@@ -60,7 +60,6 @@ class UtilTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testParseInt);
   CPPUNIT_TEST(testParseUInt);
   CPPUNIT_TEST(testParseLLInt);
-  CPPUNIT_TEST(testParseULLInt);
   CPPUNIT_TEST(testParseIntNoThrow);
   CPPUNIT_TEST(testParseUIntNoThrow);
   CPPUNIT_TEST(testParseLLIntNoThrow);
@@ -132,7 +131,6 @@ public:
   void testParseInt();
   void testParseUInt();
   void testParseLLInt();
-  void testParseULLInt();
   void testParseIntNoThrow();
   void testParseUIntNoThrow();
   void testParseLLIntNoThrow();
@@ -1345,26 +1343,6 @@ void UtilTest::testParseLLInt()
   }
 }
 
-void UtilTest::testParseULLInt()
-{
-  std::string s;
-  s = "9223372036854775807";
-  CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807LL,
-                       util::parseULLInt(s));
-  try {
-    s = "-1";
-    util::parseULLInt(s);
-    CPPUNIT_FAIL("exception must be thrown.");
-  } catch(Exception& e) {
-  }
-  try {
-    s = "9223372036854775808";
-    util::parseULLInt(s);
-    CPPUNIT_FAIL("exception must be thrown.");
-  } catch(Exception& e) {
-  }
-}
-
 void UtilTest::testParseIntNoThrow()
 {
   std::string s;