Stored hash value as raw byte string, instead of hex digest.

src/BtPieceMessage.cc

@@ -223,11 +223,10 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece)
     A2_LOG_DEBUG(fmt("Hash is available!! index=%lu",
                      static_cast<unsigned long>(piece->getIndex())));
     return
-      piece->getHashString()==downloadContext_->getPieceHash(piece->getIndex());
+      piece->getDigest() == downloadContext_->getPieceHash(piece->getIndex());
   } else {
     off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength();
-    
+    return message_digest::staticSHA1Digest
-    return message_digest::staticSHA1DigestHexDigest
       (getPieceStorage()->getDiskAdaptor(), offset, piece->getLength())
       == downloadContext_->getPieceHash(piece->getIndex());
   }

src/Checksum.h

@@ -46,7 +46,7 @@ private:
   std::string hashType_;
   std::string digest_;
 public:
-  // messageDigest_ is ascii hexadecimal notation.
+  // digest_ is raw byte array of hash value, not ascii hexadecimal notation.
   Checksum(const std::string& hashType, const std::string& digest);
   Checksum();
   ~Checksum();

src/DownloadCommand.cc

@@ -231,12 +231,12 @@ bool DownloadCommand::executeInternal() {
             A2_LOG_DEBUG(fmt("Hash is available! index=%lu",
                              static_cast<unsigned long>(segment->getIndex())));
             validatePieceHash
-              (segment, expectedPieceHash, segment->getHashString());
+              (segment, expectedPieceHash, segment->getDigest());
           } else {
             messageDigest_->reset();
             validatePieceHash
               (segment, expectedPieceHash,
-               message_digest::hexDigest
+               message_digest::digest
                (messageDigest_,
                 getPieceStorage()->getDiskAdaptor(),
                 segment->getPosition(),
@@ -350,18 +350,18 @@ bool DownloadCommand::prepareForNextSegment() {
 #ifdef ENABLE_MESSAGE_DIGEST
 
 void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment,
-                                        const std::string& expectedPieceHash,
+                                        const std::string& expectedHash,
-                                        const std::string& actualPieceHash)
+                                        const std::string& actualHash)
 {
-  if(actualPieceHash == expectedPieceHash) {
+  if(actualHash == expectedHash) {
-    A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, actualPieceHash.c_str()));
+    A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, util::toHex(actualHash).c_str()));
     getSegmentMan()->completeSegment(getCuid(), segment);
   } else {
     A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM,
                     static_cast<unsigned long>(segment->getIndex()),
                     util::itos(segment->getPosition(), true).c_str(),
-                    expectedPieceHash.c_str(),
+                    util::toHex(expectedHash).c_str(),
-                    actualPieceHash.c_str()));
+                    util::toHex(actualHash).c_str()));
     segment->clear();
     getSegmentMan()->cancelSegment(getCuid());
     throw DL_RETRY_EX

src/GrowSegment.cc

@@ -52,7 +52,7 @@ void GrowSegment::updateWrittenLength(size_t bytes)
 
 #ifdef ENABLE_MESSAGE_DIGEST
 
-std::string GrowSegment::getHashString()
+std::string GrowSegment::getDigest()
 {
   return A2STR::NIL;
 }

src/GrowSegment.h

@@ -98,7 +98,7 @@ public:
     return false;
   }
 
-  virtual std::string getHashString();
+  virtual std::string getDigest();
 
 #endif // ENABLE_MESSAGE_DIGEST
 

src/HttpResponse.cc

@@ -408,11 +408,12 @@ void HttpResponse::getDigest(std::vector<Checksum>& result) const
         break;
       }
       util::lowercase(hashType);
-      std::string hexDigest = util::toHex(Base64::decode(digest));
+      digest = Base64::decode(digest);
-      if(!MessageDigest::isValidHash(hashType, hexDigest)) {
+      if(!MessageDigest::supports(hashType) ||
+         MessageDigest::getDigestLength(hashType) != digest.size()) {
         continue;
       }
-      result.push_back(Checksum(hashType, hexDigest));
+      result.push_back(Checksum(hashType, digest));
     }
   }
   std::sort(result.begin(), result.end(), HashTypeStronger());

src/IteratableChecksumValidator.cc

@@ -75,12 +75,13 @@ void IteratableChecksumValidator::validateChunk()
     ctx_->update(buffer_, length);
     currentOffset_ += length;
     if(finished()) {
-      std::string actualDigest = ctx_->hexDigest();
+      std::string actualDigest = ctx_->digest();
       if(dctx_->getDigest() == actualDigest) {
         pieceStorage_->markAllPiecesDone();
       } else {
         A2_LOG_INFO(fmt("Checksum validation failed. expected=%s, actual=%s",
-                        dctx_->getDigest().c_str(), actualDigest.c_str()));
+                        util::toHex(dctx_->getDigest()).c_str(),
+                        util::toHex(actualDigest).c_str()));
         BitfieldMan bitfield(dctx_->getPieceLength(), dctx_->getTotalLength());
         pieceStorage_->setBitfield(bitfield.getBitfield(), bitfield.getBitfieldLength());
       }

src/IteratableChunkChecksumValidator.cc

@@ -82,11 +82,12 @@ void IteratableChunkChecksumValidator::validateChunk()
       if(actualChecksum == dctx_->getPieceHashes()[currentIndex_]) {
         bitfield_->setBit(currentIndex_);
       } else {
-        A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM,
+        A2_LOG_INFO
-                        static_cast<unsigned long>(currentIndex_),
+          (fmt(EX_INVALID_CHUNK_CHECKSUM,
-                        util::itos(getCurrentOffset(), true).c_str(),
+               static_cast<unsigned long>(currentIndex_),
-                        dctx_->getPieceHashes()[currentIndex_].c_str(),
+               util::itos(getCurrentOffset(), true).c_str(),
-                        actualChecksum.c_str()));
+               util::toHex(dctx_->getPieceHashes()[currentIndex_]).c_str(),
+               util::toHex(actualChecksum).c_str()));
         bitfield_->unsetBit(currentIndex_);
       }
     } catch(RecoverableException& ex) {
@@ -156,7 +157,7 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length
     curoffset += r;
     woffset = 0;
   }
-  return ctx_->hexDigest();
+  return ctx_->digest();
 }
 
 

src/MessageDigest.cc

@@ -172,12 +172,12 @@ void MessageDigest::digest(unsigned char* md)
   pImpl_->digest(md);
 }
 
-std::string MessageDigest::hexDigest()
+std::string MessageDigest::digest()
 {
   size_t length = pImpl_->getDigestLength();
   array_ptr<unsigned char> buf(new unsigned char[length]);
   pImpl_->digest(buf);
-  std::string hd = util::toHex(buf, length);
+  std::string hd(&buf[0], &buf[length]);
   return hd;
 }
 

src/MessageDigest.h

@@ -101,9 +101,9 @@ public:
   // reset().
   void digest(unsigned char* md);
 
-  // Returns hex digest.  This call can only be called once. To reuse
+  // Returns raw digest, not hex digest.  This call can only be called
-  // this object, call reset().
+  // once. To reuse this object, call reset().
-  std::string hexDigest();
+  std::string digest();
 };
 
 } // namespace aria2

src/MetalinkParserController.cc

@@ -284,7 +284,7 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md)
     return;
   }
   if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) {
-    tChecksum_->setDigest(md);
+    tChecksum_->setDigest(util::fromHex(md));
   } else {
     cancelChecksumTransaction();
   }
@@ -360,7 +360,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md)
     return;
   }
   if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) {
-    tempChunkChecksumsV4_.push_back(md);
+    tempChunkChecksumsV4_.push_back(util::fromHex(md));
   } else {
     cancelChunkChecksumTransactionV4();
   }
@@ -463,7 +463,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string
     return;
   }
   if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
-    tempHashPair_.second = md;
+    tempHashPair_.second = util::fromHex(md);
   } else {
     cancelChunkChecksumTransaction();
   }

src/Piece.cc

@@ -218,12 +218,12 @@ bool Piece::isHashCalculated() const
   return mdctx_ && nextBegin_ == length_;
 }
 
-std::string Piece::getHashString()
+std::string Piece::getDigest()
 {
   if(!mdctx_) {
     return A2STR::NIL;
   } else {
-    std::string hash = mdctx_->hexDigest();
+    std::string hash = mdctx_->digest();
     destroyHashContext();
     return hash;
   }

src/Piece.h

@@ -164,11 +164,11 @@ public:
 
   bool isHashCalculated() const;
 
-  // Returns hash value in ASCII hexadecimal form, which is calculated
+  // Returns raw hash value, not hex digest, which is calculated
   // by updateHash().  Please note that this function returns hash
   // value only once. Second invocation without updateHash() returns
   // empty string.
-  std::string getHashString();
+  std::string getDigest();
 
   void destroyHashContext();
 

src/PiecedSegment.cc

@@ -102,9 +102,9 @@ bool PiecedSegment::isHashCalculated() const
   return piece_->isHashCalculated();
 }
 
-std::string PiecedSegment::getHashString()
+std::string PiecedSegment::getDigest()
 {
-  return piece_->getHashString();
+  return piece_->getDigest();
 }
 
 #endif // ENABLE_MESSAGE_DIGEST

src/PiecedSegment.h

@@ -84,7 +84,7 @@ public:
 
   virtual bool isHashCalculated() const;
 
-  virtual std::string getHashString();
+  virtual std::string getDigest();
 
 #endif // ENABLE_MESSAGE_DIGEST
 

src/Segment.h

@@ -74,7 +74,7 @@ public:
 
   virtual bool isHashCalculated() const = 0;
 
-  virtual std::string getHashString() = 0;
+  virtual std::string getDigest() = 0;
 
 #endif // ENABLE_MESSAGE_DIGEST
 

src/bittorrent_helper.cc

@@ -119,8 +119,8 @@ void extractPieceHash(const SharedHandle<DownloadContext>& ctx,
   std::vector<std::string> pieceHashes;
   pieceHashes.reserve(numPieces);
   for(size_t i = 0; i < numPieces; ++i) {
-    pieceHashes.push_back(util::toHex(hashData.data()+i*hashLength,
+    const char* p = hashData.data()+i*hashLength;
-                                      hashLength));
+    pieceHashes.push_back(std::string(p, p+hashLength));
   }
   ctx->setPieceHashes("sha-1", pieceHashes.begin(), pieceHashes.end());
 }

src/download_helper.cc

@@ -238,7 +238,7 @@ SharedHandle<RequestGroup> createRequestGroup
     util::divide(p, checksum, '=');
     util::lowercase(p.first);
     util::lowercase(p.second);
-    dctx->setDigest(p.first, p.second);
+    dctx->setDigest(p.first, util::fromHex(p.second));
   }
 #endif // ENABLE_MESSAGE_DIGEST
   rg->setDownloadContext(dctx);

src/message_digest_helper.cc

@@ -65,14 +65,14 @@ void staticSHA1DigestFree()
   sha1Ctx_.reset();
 }
 
-std::string staticSHA1DigestHexDigest
+std::string staticSHA1Digest
 (const BinaryStreamHandle& bs, off_t offset, uint64_t length)
 {
   sha1Ctx_->reset();
-  return hexDigest(sha1Ctx_, bs, offset, length);
+  return digest(sha1Ctx_, bs, offset, length);
 }
 
-std::string hexDigest
+std::string digest
 (const SharedHandle<MessageDigest>& ctx,
  const SharedHandle<BinaryStream>& bs,
  off_t offset, uint64_t length)
@@ -97,7 +97,7 @@ std::string hexDigest
     }
     ctx->update(BUF, readLength);
   }
-  return ctx->hexDigest();
+  return ctx->digest();
 }
 
 void digest

src/message_digest_helper.h

@@ -62,14 +62,14 @@ void staticSHA1DigestInit();
  */
 void staticSHA1DigestFree();
 
-std::string staticSHA1DigestHexDigest
+std::string staticSHA1Digest
 (const SharedHandle<BinaryStream>& bs, off_t offset, uint64_t length);
 
 /**
  * ctx must be initialized or reseted before calling this function.
- * Returns hex digest string, not *raw* digest
+ * Returns raw digest string, not hex digest
  */
-std::string hexDigest
+std::string digest
 (const SharedHandle<MessageDigest>& ctx,
  const SharedHandle<BinaryStream>& bs,
  off_t offset, uint64_t length);

test/BittorrentHelperTest.cc

@@ -148,11 +148,11 @@ void BittorrentHelperTest::testGetPieceHash() {
   SharedHandle<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/test.torrent", dctx, option_);
 
-  CPPUNIT_ASSERT_EQUAL(util::toHex("AAAAAAAAAAAAAAAAAAAA", 20),
+  CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAAAAAAAAAAAAAA"),
                        dctx->getPieceHash(0));
-  CPPUNIT_ASSERT_EQUAL(util::toHex("BBBBBBBBBBBBBBBBBBBB", 20),
+  CPPUNIT_ASSERT_EQUAL(std::string("BBBBBBBBBBBBBBBBBBBB"),
                        dctx->getPieceHash(1));
-  CPPUNIT_ASSERT_EQUAL(util::toHex("CCCCCCCCCCCCCCCCCCCC", 20),
+  CPPUNIT_ASSERT_EQUAL(std::string("CCCCCCCCCCCCCCCCCCCC"),
                        dctx->getPieceHash(2));
   CPPUNIT_ASSERT_EQUAL(std::string(""),
                        dctx->getPieceHash(3));

test/GZipDecodingStreamFilterTest.cc

@@ -76,7 +76,7 @@ void GZipDecodingStreamFilterTest::testTransform()
   SharedHandle<MessageDigest> sha1(MessageDigest::sha1());
   sha1->update(data.data(), data.size());
   CPPUNIT_ASSERT_EQUAL(std::string("8b577b33c0411b2be9d4fa74c7402d54a8d21f96"),
-                       sha1->hexDigest());
+                       util::toHex(sha1->digest()));
 #endif // ENABLE_MESSAGE_DIGEST
 }
 

test/HttpResponseTest.cc

@@ -681,12 +681,12 @@ void HttpResponseTest::testGetDigest()
   Checksum c = result[0];
   CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType());
   CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"),
-                       c.getDigest());
+                       util::toHex(c.getDigest()));
 
   c = result[1];
   CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType());
   CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
-                       c.getDigest());
+                       util::toHex(c.getDigest()));
 }
 #endif // ENABLE_MESSAGE_DIGEST
 

test/IteratableChecksumValidatorTest.cc

@@ -34,7 +34,8 @@ void IteratableChecksumValidatorTest::testValidate() {
   Option option;
   SharedHandle<DownloadContext> dctx
     (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
-  dctx->setDigest("sha-1", "898a81b8e0181280ae2ee1b81e269196d91e869a");
+  dctx->setDigest("sha-1",
+                  util::fromHex("898a81b8e0181280ae2ee1b81e269196d91e869a"));
   SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();
@@ -53,7 +54,8 @@ void IteratableChecksumValidatorTest::testValidate_fail() {
   Option option;
   SharedHandle<DownloadContext> dctx
     (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
-  dctx->setDigest("sha-1", std::string(40, '0')); // set wrong checksum
+  dctx->setDigest("sha-1",
+                  util::fromHex(std::string(40, '0'))); // set wrong checksum
   SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();
   ps->getDiskAdaptor()->enableReadOnly();

test/IteratableChunkChecksumValidatorTest.cc

@@ -19,7 +19,7 @@ class IteratableChunkChecksumValidatorTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 private:
 
-  static const char* csArray[];
+  static const std::string csArray[];
 public:
   void setUp() {
   }
@@ -31,9 +31,10 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( IteratableChunkChecksumValidatorTest );
 
-const char* IteratableChunkChecksumValidatorTest::csArray[] = { "29b0e7878271645fffb7eec7db4a7473a1c00bc1",
+const std::string IteratableChunkChecksumValidatorTest::csArray[] =
-                                                                "4df75a661cb7eb2733d9cdaa7f772eae3a4e2976",
+  { util::fromHex("29b0e7878271645fffb7eec7db4a7473a1c00bc1"),
-                                                                "0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb" };
+    util::fromHex("4df75a661cb7eb2733d9cdaa7f772eae3a4e2976"),
+    util::fromHex("0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb") };
 
 void IteratableChunkChecksumValidatorTest::testValidate() {
   Option option;
@@ -59,7 +60,7 @@ void IteratableChunkChecksumValidatorTest::testValidate() {
 
   // make the test fail
   std::deque<std::string> badHashes(&csArray[0], &csArray[3]);
-  badHashes[1] = "ffffffffffffffffffffffffffffffffffffffff";
+  badHashes[1] = util::fromHex("ffffffffffffffffffffffffffffffffffffffff");
   dctx->setPieceHashes("sha-1", badHashes.begin(), badHashes.end());
 
   validator.init();
@@ -77,8 +78,8 @@ void IteratableChunkChecksumValidatorTest::testValidate_readError() {
   SharedHandle<DownloadContext> dctx
     (new DownloadContext(100, 500, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
   std::deque<std::string> hashes(&csArray[0], &csArray[3]);
-  hashes.push_back("ffffffffffffffffffffffffffffffffffffffff");
+  hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff"));
-  hashes.push_back("ffffffffffffffffffffffffffffffffffffffff");
+  hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff"));
   dctx->setPieceHashes("sha-1", hashes.begin(), hashes.end());
   SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
   ps->initStorage();

test/MessageDigestHelperTest.cc

@@ -11,7 +11,7 @@ namespace aria2 {
 class MessageDigestHelperTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MessageDigestHelperTest);
-  CPPUNIT_TEST(testHexDigestDiskWriter);
+  CPPUNIT_TEST(testDigestDiskWriter);
   CPPUNIT_TEST_SUITE_END();
 private:
 
@@ -19,24 +19,24 @@ public:
   void setUp() {
   }
 
-  void testHexDigestDiskWriter();
+  void testDigestDiskWriter();
 };
 
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestHelperTest );
 
-void MessageDigestHelperTest::testHexDigestDiskWriter() {
+void MessageDigestHelperTest::testDigestDiskWriter() {
   SharedHandle<DefaultDiskWriter> diskio
     (new DefaultDiskWriter(A2_TEST_DIR"/4096chunk.txt"));
   diskio->enableReadOnly();
   diskio->openExistingFile();
   CPPUNIT_ASSERT_EQUAL(std::string("608cabc0f2fa18c260cafd974516865c772363d5"),
-                       message_digest::hexDigest
+                       util::toHex(message_digest::digest
-                       (MessageDigest::sha1(), diskio, 0, 4096));
+                                   (MessageDigest::sha1(), diskio, 0, 4096)));
 
   CPPUNIT_ASSERT_EQUAL(std::string("7a4a9ae537ebbbb826b1060e704490ad0f365ead"),
-                       message_digest::hexDigest
+                       util::toHex(message_digest::digest
-                       (MessageDigest::sha1(), diskio, 5, 100));
+                                   (MessageDigest::sha1(), diskio, 5, 100)));
 }
 
 } // namespace aria2

test/MessageDigestTest.cc

@@ -9,7 +9,7 @@ namespace aria2 {
 class MessageDigestTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MessageDigestTest);
-  CPPUNIT_TEST(testHexDigest);
+  CPPUNIT_TEST(testDigest);
   CPPUNIT_TEST(testSupports);
   CPPUNIT_TEST(testGetDigestLength);
   CPPUNIT_TEST(testIsStronger);
@@ -24,7 +24,7 @@ public:
     sha1_ = MessageDigest::sha1();
   }
 
-  void testHexDigest();
+  void testDigest();
   void testSupports();
   void testGetDigestLength();
   void testIsStronger();
@@ -35,11 +35,11 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestTest );
 
-void MessageDigestTest::testHexDigest()
+void MessageDigestTest::testDigest()
 {
   sha1_->update("aria2", 5);
   CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
-                       sha1_->hexDigest());
+                       util::toHex(sha1_->digest()));
 }
 
 void MessageDigestTest::testSupports()

test/Metalink2RequestGroupTest.cc

@@ -63,7 +63,7 @@ void Metalink2RequestGroupTest::testGenerate()
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
     CPPUNIT_ASSERT_EQUAL
       (std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
-       dctx->getDigest());
+       util::toHex(dctx->getDigest()));
 #endif // ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(dctx->getSignature());
     CPPUNIT_ASSERT_EQUAL(std::string("pgp"), dctx->getSignature()->getType());
@@ -85,7 +85,7 @@ void Metalink2RequestGroupTest::testGenerate()
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
     CPPUNIT_ASSERT_EQUAL
       (std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
-       dctx->getDigest());
+       util::toHex(dctx->getDigest()));
 #endif // ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(!dctx->getSignature());
   }

test/MetalinkParserControllerTest.cc

@@ -207,7 +207,7 @@ void MetalinkParserControllerTest::testChecksumTransaction()
     SharedHandle<Checksum> md = m->getEntries().front()->checksum;
     CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
     CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getDigest());
+                         util::toHex(md->getDigest()));
   }
   ctrl.newEntryTransaction();
   ctrl.newChecksumTransaction();
@@ -288,13 +288,13 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
     CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
     CPPUNIT_ASSERT_EQUAL
       (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
-       md->getPieceHashes()[0]);
+       util::toHex(md->getPieceHashes()[0]));
     CPPUNIT_ASSERT_EQUAL
       (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
-       md->getPieceHashes()[1]);
+       util::toHex(md->getPieceHashes()[1]));
     CPPUNIT_ASSERT_EQUAL
       (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
-       md->getPieceHashes()[2]);
+       util::toHex(md->getPieceHashes()[2]));
   }
   ctrl.newEntryTransaction();
   ctrl.newChunkChecksumTransactionV4();

test/MetalinkProcessorTest.cc

@@ -20,6 +20,7 @@
 #include "Signature.h"
 #include "fmt.h"
 #include "RecoverableException.h"
+#include "util.h"
 
 namespace aria2 {
 
@@ -93,7 +94,7 @@ void MetalinkProcessorTest::testParseFileV4()
   CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
   CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
-		       e->checksum->getDigest());
+		       util::toHex(e->checksum->getDigest()));
   CPPUNIT_ASSERT(e->checksum);
   CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType());
   CPPUNIT_ASSERT(e->chunkChecksum);
@@ -102,24 +103,24 @@ void MetalinkProcessorTest::testParseFileV4()
     CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
     CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
     CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"),
-                         e->chunkChecksum->getPieceHash(0));
+                         util::toHex(e->chunkChecksum->getPieceHash(0)));
     CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"),
-                         e->chunkChecksum->getPieceHash(1));
+                         util::toHex(e->chunkChecksum->getPieceHash(1)));
     CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"),
-                         e->chunkChecksum->getPieceHash(2));
+                         util::toHex(e->chunkChecksum->getPieceHash(2)));
   } else {
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getHashType());
     CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
     CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
     CPPUNIT_ASSERT_EQUAL
       (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
-       e->chunkChecksum->getPieceHash(0));
+       util::toHex(e->chunkChecksum->getPieceHash(0)));
     CPPUNIT_ASSERT_EQUAL
       (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
-       e->chunkChecksum->getPieceHash(1));
+       util::toHex(e->chunkChecksum->getPieceHash(1)));
     CPPUNIT_ASSERT_EQUAL
       (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
-       e->chunkChecksum->getPieceHash(2));
+       util::toHex(e->chunkChecksum->getPieceHash(2)));
   }
 #endif // ENABLE_MESSAGE_DIGEST
   CPPUNIT_ASSERT(e->getSignature());
@@ -508,7 +509,7 @@ void MetalinkProcessorTest::testParseFile()
     CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
-                         entry1->checksum->getDigest());
+                         util::toHex(entry1->checksum->getDigest()));
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(entry1->getSignature());
@@ -557,13 +558,13 @@ void MetalinkProcessorTest::testParseFile()
     CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
-                         entry2->checksum->getDigest());
+                         util::toHex(entry2->checksum->getDigest()));
     CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countPieceHash());
     CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getPieceLength());
     CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
-                         entry2->chunkChecksum->getPieceHash(0));
+                         util::toHex(entry2->chunkChecksum->getPieceHash(0)));
     CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
-                         entry2->chunkChecksum->getPieceHash(1));
+                         util::toHex(entry2->chunkChecksum->getPieceHash(1)));
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
     // See that signature is null
@@ -587,7 +588,7 @@ void MetalinkProcessorTest::testParseFile()
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
     CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
-                         entry4->checksum->getDigest());
+                         util::toHex(entry4->checksum->getDigest()));
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
 

test/MockSegment.h

@@ -60,7 +60,7 @@ public:
     return false;
   }
 
-  virtual std::string getHashString()
+  virtual std::string getDigest()
   {
     return A2STR::NIL;
   }

test/PieceTest.cc

@@ -4,6 +4,8 @@
 
 #include <cppunit/extensions/HelperMacros.h>
 
+#include "util.h"
+
 namespace aria2 {
 
 class PieceTest:public CppUnit::TestFixture {
@@ -81,7 +83,7 @@ void PieceTest::testUpdateHash()
   CPPUNIT_ASSERT(p.isHashCalculated());
 
   CPPUNIT_ASSERT_EQUAL(std::string("d9189aff79e075a2e60271b9556a710dc1bc7de7"),
-                       p.getHashString());
+                       util::toHex(p.getDigest()));
 }
 
 #endif // ENABLE_MESSAGE_DIGEST

test/TestUtil.cc

@@ -14,6 +14,7 @@
 #include "Cookie.h"
 #include "DefaultDiskWriter.h"
 #include "fmt.h"
+#include "util.h"
 #ifdef ENABLE_MESSAGE_DIGEST
 # include "message_digest_helper.h"
 #endif // ENABLE_MESSAGE_DIGEST
@@ -81,7 +82,7 @@ std::string fileHexDigest
 {
   SharedHandle<DiskWriter> writer(new DefaultDiskWriter(filename));
   writer->openExistingFile();
-  return message_digest::hexDigest(ctx, writer, 0, writer->size());
+  return util::toHex(message_digest::digest(ctx, writer, 0, writer->size()));
 }
 #endif // ENABLE_MESSAGE_DIGEST