github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Consistent naming scheme for hash type and digest.

pull/1/head
Tatsuhiro Tsujikawa 2011-07-27 21:44:54 +09:00
parent ce101f5ad2
commit 7b86b294c9
11 changed files with 154 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/Checksum.cc
View File

@ -37,38 +37,40 @@
namespace aria2 {
Checksum::Checksum(const std::string& algo, const std::string& messageDigest)
: algo_(algo),
messageDigest_(messageDigest)
Checksum::Checksum
(const std::string& hashType,
const std::string& digest)
: hashType_(hashType),
digest_(digest)
{}
Checksum::Checksum()
: algo_("sha-1")
: hashType_("sha-1")
{}
Checksum::~Checksum() {}
bool Checksum::isEmpty() const
{
return messageDigest_.empty();
return digest_.empty();
}
void Checksum::setMessageDigest(const std::string& md)
void Checksum::setDigest(const std::string& digest)
{
messageDigest_ = md;
digest_ = digest;
}
void Checksum::setAlgo(const std::string& algo)
void Checksum::setHashType(const std::string& hashType)
{
algo_ = algo;
hashType_ = hashType;
}
void Checksum::swap(Checksum& other)
{
using std::swap;
if(this != &other) {
swap(algo_, other.algo_);
swap(messageDigest_, other.messageDigest_);
swap(hashType_, other.hashType_);
swap(digest_, other.digest_);
}
}
@ -80,7 +82,7 @@ void swap(Checksum& a, Checksum& b)
bool HashTypeStronger::operator()
(const Checksum& lhs, const Checksum& rhs) const
{
return MessageDigest::isStronger(lhs.getAlgo(), rhs.getAlgo());
return MessageDigest::isStronger(lhs.getHashType(), rhs.getHashType());
}
} // namespace aria2

18
src/Checksum.h
View File

@ -43,26 +43,26 @@ namespace aria2 {
class Checksum {
private:
std::string algo_;
std::string messageDigest_;
std::string hashType_;
std::string digest_;
public:
// messageDigest_ is ascii hexadecimal notation.
Checksum(const std::string& algo, const std::string& messageDigest);
Checksum(const std::string& hashType, const std::string& digest);
Checksum();
~Checksum();
bool isEmpty() const;
void setMessageDigest(const std::string& md);
const std::string& getMessageDigest() const
void setDigest(const std::string& md);
const std::string& getDigest() const
{
return messageDigest_;
return digest_;
}
void setAlgo(const std::string& algo);
const std::string& getAlgo() const
void setHashType(const std::string& type);
const std::string& getHashType() const
{
return algo_;
return hashType_;
}
void swap(Checksum& other);

45
src/ChunkChecksum.cc
View File

@ -37,55 +37,52 @@
namespace aria2 {
ChunkChecksum::ChunkChecksum():checksumLength_(0) {}
ChunkChecksum::ChunkChecksum():pieceLength_(0) {}
ChunkChecksum::ChunkChecksum
(const std::string& algo,
const std::vector<std::string>& checksums,
size_t checksumLength)
: algo_(algo),
checksums_(checksums),
checksumLength_(checksumLength)
(const std::string& hashType,
const std::vector<std::string>& pieceHashes,
size_t pieceLength)
: hashType_(hashType),
pieceHashes_(pieceHashes),
pieceLength_(pieceLength)
{}
bool ChunkChecksum::validateChunk
(const std::string& actualChecksum,
size_t checksumIndex) const
(const std::string& actualDigest,
size_t index) const
{
if(checksumIndex < checksums_.size()) {
return actualChecksum == getChecksum(checksumIndex);
} else {
return false;
}
const std::string& digest = getPieceHash(index);
return !digest.empty() && actualDigest == digest;
}
uint64_t ChunkChecksum::getEstimatedDataLength() const
{
return static_cast<uint64_t>(checksumLength_)*checksums_.size();
return static_cast<uint64_t>(pieceLength_)*pieceHashes_.size();
}
size_t ChunkChecksum::countChecksum() const
size_t ChunkChecksum::countPieceHash() const
{
return checksums_.size();
return pieceHashes_.size();
}
const std::string& ChunkChecksum::getChecksum(size_t index) const
const std::string& ChunkChecksum::getPieceHash(size_t index) const
{
if(index < checksums_.size()) {
return checksums_[index];
if(index < pieceHashes_.size()) {
return pieceHashes_[index];
} else {
return A2STR::NIL;
}
}
void ChunkChecksum::setAlgo(const std::string& algo)
void ChunkChecksum::setHashType(const std::string& hashType)
{
algo_ = algo;
hashType_ = hashType;
}
void ChunkChecksum::setChecksums(const std::vector<std::string>& mds)
void ChunkChecksum::setPieceHashes(const std::vector<std::string>& pieceHashes)
{
checksums_ = mds;
pieceHashes_ = pieceHashes;
}
} // namespace aria2

41
src/ChunkChecksum.h
View File

@ -46,45 +46,46 @@ namespace aria2 {
class ChunkChecksum {
private:
std::string algo_;
std::vector<std::string> checksums_;
size_t checksumLength_;
std::string hashType_;
std::vector<std::string> pieceHashes_;
size_t pieceLength_;
public:
ChunkChecksum();
ChunkChecksum(const std::string& algo,
const std::vector<std::string>& checksums,
size_t checksumLength);
ChunkChecksum
(const std::string& hashType,
const std::vector<std::string>& pieceHashes,
size_t pieceLength);
bool validateChunk(const std::string& actualChecksum,
size_t checksumIndex) const;
bool validateChunk(const std::string& actualDigest,
size_t index) const;
uint64_t getEstimatedDataLength() const;
size_t countChecksum() const;
size_t countPieceHash() const;
const std::string& getChecksum(size_t index) const;
const std::string& getPieceHash(size_t index) const;
void setChecksums(const std::vector<std::string>& mds);
const std::vector<std::string>& getChecksums() const
void setPieceHashes(const std::vector<std::string>& pieceHashes);
const std::vector<std::string>& getPieceHashes() const
{
return checksums_;
return pieceHashes_;
}
size_t getChecksumLength() const
void setHashType(const std::string& hashType);
const std::string& getHashType() const
{
return checksumLength_;
return hashType_;
}
void setAlgo(const std::string& algo);
const std::string& getAlgo() const
size_t getPieceLength() const
{
return algo_;
return pieceLength_;
}
void setChecksumLength(size_t length)
void setPieceLength(size_t length)
{
checksumLength_ = length;
pieceLength_ = length;
}
};

4
src/HttpResponse.cc
View File

@ -424,10 +424,10 @@ void HttpResponse::getDigest(std::vector<Checksum>& result) const
bool ok = true;
std::vector<Checksum>::iterator j = i+1;
for(; j != eoi; ++j) {
if((*i).getAlgo() != (*j).getAlgo()) {
if((*i).getHashType() != (*j).getHashType()) {
break;
}
if((*i).getMessageDigest() != (*j).getMessageDigest()) {
if((*i).getDigest() != (*j).getDigest()) {
ok = false;
}
}

12
src/HttpResponseCommand.cc
View File

@ -215,10 +215,10 @@ bool HttpResponseCommand::executeInternal()
eoi = checksums.end(); i != eoi; ++i) {
if(getDownloadContext()->getChecksumHashAlgo().empty()) {
A2_LOG_DEBUG(fmt("Setting digest: type=%s, digest=%s",
(*i).getAlgo().c_str(),
(*i).getMessageDigest().c_str()));
getDownloadContext()->setChecksumHashAlgo((*i).getAlgo());
getDownloadContext()->setChecksum((*i).getMessageDigest());
(*i).getHashType().c_str(),
(*i).getDigest().c_str()));
getDownloadContext()->setChecksumHashAlgo((*i).getHashType());
getDownloadContext()->setChecksum((*i).getDigest());
break;
} else {
if(checkChecksum(getDownloadContext(), *i)) {
@ -559,8 +559,8 @@ bool HttpResponseCommand::checkChecksum
(const SharedHandle<DownloadContext>& dctx,
const Checksum& checksum)
{
if(dctx->getChecksumHashAlgo() == checksum.getAlgo()) {
if(dctx->getChecksum() == checksum.getMessageDigest()) {
if(dctx->getChecksumHashAlgo() == checksum.getHashType()) {
if(dctx->getChecksum() == checksum.getDigest()) {
A2_LOG_INFO("Valid hash found in Digest header field.");
return true;
} else {

12
src/Metalink2RequestGroup.cc
View File

@ -245,7 +245,7 @@ Metalink2RequestGroup::createRequestGroup
if(!entry->chunkChecksum) {
pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
} else {
pieceLength = entry->chunkChecksum->getChecksumLength();
pieceLength = entry->chunkChecksum->getPieceLength();
}
#else
pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
@ -263,13 +263,13 @@ Metalink2RequestGroup::createRequestGroup
}
#ifdef ENABLE_MESSAGE_DIGEST
if(entry->checksum) {
dctx->setChecksum(entry->checksum->getMessageDigest());
dctx->setChecksumHashAlgo(entry->checksum->getAlgo());
dctx->setChecksum(entry->checksum->getDigest());
dctx->setChecksumHashAlgo(entry->checksum->getHashType());
}
if(entry->chunkChecksum) {
dctx->setPieceHashes(entry->chunkChecksum->getChecksums().begin(),
entry->chunkChecksum->getChecksums().end());
dctx->setPieceHashAlgo(entry->chunkChecksum->getAlgo());
dctx->setPieceHashes(entry->chunkChecksum->getPieceHashes().begin(),
entry->chunkChecksum->getPieceHashes().end());
dctx->setPieceHashAlgo(entry->chunkChecksum->getHashType());
}
#endif // ENABLE_MESSAGE_DIGEST
dctx->setSignature(entry->getSignature());

44
src/MetalinkParserController.cc
View File

@ -270,7 +270,7 @@ void MetalinkParserController::setTypeOfChecksum(const std::string& type)
}
std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) {
tChecksum_->setAlgo(calgo);
tChecksum_->setHashType(calgo);
} else {
cancelChecksumTransaction();
}
@ -283,8 +283,8 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md)
if(!tChecksum_) {
return;
}
if(MessageDigest::isValidHash(tChecksum_->getAlgo(), md)) {
tChecksum_->setMessageDigest(md);
if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) {
tChecksum_->setDigest(md);
} else {
cancelChecksumTransaction();
}
@ -298,8 +298,8 @@ void MetalinkParserController::commitChecksumTransaction()
return;
}
if(!tEntry_->checksum ||
MessageDigest::isStronger(tChecksum_->getAlgo(),
tEntry_->checksum->getAlgo())) {
MessageDigest::isStronger(tChecksum_->getHashType(),
tEntry_->checksum->getHashType())) {
tEntry_->checksum = tChecksum_;
}
tChecksum_.reset();
@ -332,7 +332,7 @@ void MetalinkParserController::setTypeOfChunkChecksumV4(const std::string& type)
}
std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) {
tChunkChecksumV4_->setAlgo(calgo);
tChunkChecksumV4_->setHashType(calgo);
} else {
cancelChunkChecksumTransactionV4();
}
@ -346,7 +346,7 @@ void MetalinkParserController::setLengthOfChunkChecksumV4(size_t length)
return;
}
if(length > 0) {
tChunkChecksumV4_->setChecksumLength(length);
tChunkChecksumV4_->setPieceLength(length);
} else {
cancelChunkChecksumTransactionV4();
}
@ -359,7 +359,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md)
if(!tChunkChecksumV4_) {
return;
}
if(MessageDigest::isValidHash(tChunkChecksumV4_->getAlgo(), md)) {
if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) {
tempChunkChecksumsV4_.push_back(md);
} else {
cancelChunkChecksumTransactionV4();
@ -374,11 +374,11 @@ void MetalinkParserController::commitChunkChecksumTransactionV4()
return;
}
if(!tEntry_->chunkChecksum ||
MessageDigest::isStronger(tChunkChecksumV4_->getAlgo(),
tEntry_->chunkChecksum->getAlgo())) {
std::vector<std::string> checksums(tempChunkChecksumsV4_.begin(),
tempChunkChecksumsV4_.end());
tChunkChecksumV4_->setChecksums(checksums);
MessageDigest::isStronger(tChunkChecksumV4_->getHashType(),
tEntry_->chunkChecksum->getHashType())) {
std::vector<std::string> pieceHashes(tempChunkChecksumsV4_.begin(),
tempChunkChecksumsV4_.end());
tChunkChecksumV4_->setPieceHashes(pieceHashes);
tEntry_->chunkChecksum = tChunkChecksumV4_;
}
tChunkChecksumV4_.reset();
@ -411,7 +411,7 @@ void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type)
}
std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) {
tChunkChecksum_->setAlgo(calgo);
tChunkChecksum_->setHashType(calgo);
} else {
cancelChunkChecksumTransaction();
}
@ -425,7 +425,7 @@ void MetalinkParserController::setLengthOfChunkChecksum(size_t length)
return;
}
if(length > 0) {
tChunkChecksum_->setChecksumLength(length);
tChunkChecksum_->setPieceLength(length);
} else {
cancelChunkChecksumTransaction();
}
@ -438,7 +438,7 @@ void MetalinkParserController::addHashOfChunkChecksum(size_t order, const std::s
if(!tChunkChecksum_) {
return;
}
if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) {
if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
tempChunkChecksums_.push_back(std::make_pair(order, md));
} else {
cancelChunkChecksumTransaction();
@ -462,7 +462,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string
if(!tChunkChecksum_) {
return;
}
if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) {
if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
tempHashPair_.second = md;
} else {
cancelChunkChecksumTransaction();
@ -487,15 +487,15 @@ void MetalinkParserController::commitChunkChecksumTransaction()
return;
}
if(!tEntry_->chunkChecksum ||
MessageDigest::isStronger(tChunkChecksum_->getAlgo(),
tEntry_->chunkChecksum->getAlgo())) {
MessageDigest::isStronger(tChunkChecksum_->getHashType(),
tEntry_->chunkChecksum->getHashType())) {
std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
Ascend1st<std::pair<size_t, std::string> >());
std::vector<std::string> checksums;
std::vector<std::string> pieceHashes;
std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
std::back_inserter(checksums),
std::back_inserter(pieceHashes),
select2nd<std::pair<size_t, std::string> >());
tChunkChecksum_->setChecksums(checksums);
tChunkChecksum_->setPieceHashes(pieceHashes);
tEntry_->chunkChecksum = tChunkChecksum_;
}
tChunkChecksum_.reset();

8
test/HttpResponseTest.cc
View File

@ -671,14 +671,14 @@ void HttpResponseTest::testGetDigest()
CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
Checksum c = result[0];
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getAlgo());
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"),
c.getMessageDigest());
c.getDigest());
c = result[1];
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getAlgo());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
c.getMessageDigest());
c.getDigest());
}
#endif // ENABLE_MESSAGE_DIGEST

32
test/MetalinkParserControllerTest.cc
View File

@ -205,9 +205,9 @@ void MetalinkParserControllerTest::testChecksumTransaction()
{
SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<Checksum> md = m->getEntries().front()->checksum;
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
md->getMessageDigest());
md->getDigest());
}
ctrl.newEntryTransaction();
ctrl.newChecksumTransaction();
@ -239,19 +239,19 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
{
SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength());
CPPUNIT_ASSERT_EQUAL((size_t)5, md->countChecksum());
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)5, md->countPieceHash());
CPPUNIT_ASSERT_EQUAL(std::string("1cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[0]);
md->getPieceHashes()[0]);
CPPUNIT_ASSERT_EQUAL(std::string("2cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[1]);
md->getPieceHashes()[1]);
CPPUNIT_ASSERT_EQUAL(std::string("3cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[2]);
md->getPieceHashes()[2]);
CPPUNIT_ASSERT_EQUAL(std::string("4cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[3]);
md->getPieceHashes()[3]);
CPPUNIT_ASSERT_EQUAL(std::string("5cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[4]);
md->getPieceHashes()[4]);
}
ctrl.newEntryTransaction();
ctrl.newChunkChecksumTransaction();
@ -283,18 +283,18 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
{
SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, md->countChecksum());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
CPPUNIT_ASSERT_EQUAL
(std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
md->getChecksums()[0]);
md->getPieceHashes()[0]);
CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"),
md->getChecksums()[1]);
md->getPieceHashes()[1]);
CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
md->getChecksums()[2]);
md->getPieceHashes()[2]);
}
ctrl.newEntryTransaction();
ctrl.newChunkChecksumTransactionV4();

66
test/MetalinkProcessorTest.cc
View File

@ -93,33 +93,33 @@ void MetalinkProcessorTest::testParseFileV4()
CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
e->checksum->getMessageDigest());
e->checksum->getDigest());
CPPUNIT_ASSERT(e->checksum);
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getAlgo());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType());
CPPUNIT_ASSERT(e->chunkChecksum);
if(MessageDigest::supports("sha-256")) {
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), e->chunkChecksum->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum());
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), 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("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"),
e->chunkChecksum->getChecksum(0));
e->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"),
e->chunkChecksum->getChecksum(1));
e->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"),
e->chunkChecksum->getChecksum(2));
e->chunkChecksum->getPieceHash(2));
} else {
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum());
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->getChecksum(0));
e->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"),
e->chunkChecksum->getChecksum(1));
e->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
e->chunkChecksum->getChecksum(2));
e->chunkChecksum->getPieceHash(2));
}
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(e->getSignature());
@ -508,8 +508,8 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
entry1->checksum->getMessageDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getAlgo());
entry1->checksum->getDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(entry1->getSignature());
CPPUNIT_ASSERT_EQUAL(std::string("pgp"), entry1->getSignature()->getType());
@ -557,14 +557,14 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry2->checksum->getMessageDigest());
CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countChecksum());
CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getChecksumLength());
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->getChecksum(0));
entry2->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
entry2->chunkChecksum->getChecksum(1));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getAlgo());
entry2->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST
// See that signature is null
CPPUNIT_ASSERT(!entry2->getSignature());
@ -585,10 +585,10 @@ void MetalinkProcessorTest::testParseFile()
SharedHandle<MetalinkEntry> entry4 = *entryItr;
CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getAlgo());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry4->checksum->getMessageDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getAlgo());
entry4->checksum->getDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST
@ -898,8 +898,8 @@ void MetalinkProcessorTest::testMultiplePieces()
SharedHandle<MetalinkEntry> e = m->getEntries()[0];
SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}
@ -932,8 +932,8 @@ void MetalinkProcessorTest::testBadPieceNo()
SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}
@ -965,8 +965,8 @@ void MetalinkProcessorTest::testBadPieceLength()
SharedHandle<MetalinkEntry> e = m->getEntries()[0];
SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}
@ -998,8 +998,8 @@ void MetalinkProcessorTest::testUnsupportedType_piece()
SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}