diff options
| -rw-r--r-- | src/ChunkChecksum.cc | 4 | ||||
| -rw-r--r-- | src/ChunkChecksum.h | 2 | ||||
| -rw-r--r-- | src/Context.cc | 10 | ||||
| -rw-r--r-- | src/DownloadContext.cc | 4 | ||||
| -rw-r--r-- | src/DownloadContext.h | 6 | ||||
| -rw-r--r-- | src/Metalink2RequestGroup.cc | 175 | ||||
| -rw-r--r-- | src/Metalink2RequestGroup.h | 8 | ||||
| -rw-r--r-- | src/MetalinkEntry.cc | 137 | ||||
| -rw-r--r-- | src/MetalinkEntry.h | 29 | ||||
| -rw-r--r-- | src/MetalinkParserController.cc | 62 | ||||
| -rw-r--r-- | src/MetalinkParserController.h | 21 | ||||
| -rw-r--r-- | src/MetalinkParserStateMachine.cc | 10 | ||||
| -rw-r--r-- | src/MetalinkParserStateMachine.h | 7 | ||||
| -rw-r--r-- | src/MetalinkResource.h | 4 | ||||
| -rw-r--r-- | src/Metalinker.cc | 66 | ||||
| -rw-r--r-- | src/Metalinker.h | 19 | ||||
| -rw-r--r-- | src/RequestGroupMan.cc | 3 | ||||
| -rw-r--r-- | src/metalink_helper.cc | 78 | ||||
| -rw-r--r-- | src/metalink_helper.h | 21 | ||||
| -rw-r--r-- | test/MetalinkEntryTest.cc | 47 | ||||
| -rw-r--r-- | test/MetalinkHelperTest.cc | 58 | ||||
| -rw-r--r-- | test/MetalinkParserControllerTest.cc | 168 | ||||
| -rw-r--r-- | test/MetalinkProcessorTest.cc | 141 | ||||
| -rw-r--r-- | test/MetalinkerTest.cc | 23 |
24 files changed, 505 insertions, 598 deletions
diff --git a/src/ChunkChecksum.cc b/src/ChunkChecksum.cc index 44748c87..68e76b1e 100644 --- a/src/ChunkChecksum.cc +++ b/src/ChunkChecksum.cc @@ -80,9 +80,9 @@ void ChunkChecksum::setHashType(const std::string& hashType) hashType_ = hashType; } -void ChunkChecksum::setPieceHashes(const std::vector<std::string>& pieceHashes) +void ChunkChecksum::setPieceHashes(std::vector<std::string> pieceHashes) { - pieceHashes_ = pieceHashes; + pieceHashes_ = std::move(pieceHashes); } } // namespace aria2 diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h index f1c0580c..4d82528a 100644 --- a/src/ChunkChecksum.h +++ b/src/ChunkChecksum.h @@ -64,7 +64,7 @@ public: const std::string& getPieceHash(size_t index) const; - void setPieceHashes(const std::vector<std::string>& pieceHashes); + void setPieceHashes(std::vector<std::string> pieceHashes); const std::vector<std::string>& getPieceHashes() const { return pieceHashes_; diff --git a/src/Context.cc b/src/Context.cc index 1d1bb315..27ca9a3f 100644 --- a/src/Context.cc +++ b/src/Context.cc @@ -99,12 +99,10 @@ namespace { void showMetalinkFile (const std::string& uri, const std::shared_ptr<Option>& op) { - std::vector<std::shared_ptr<MetalinkEntry> > metalinkEntries; - metalink::parseAndQuery(metalinkEntries, uri, op.get(), - op->get(PREF_METALINK_BASE_URI)); - std::vector<std::shared_ptr<FileEntry> > fileEntries; - MetalinkEntry::toFileEntry(fileEntries, metalinkEntries); - util::toStream(fileEntries.begin(), fileEntries.end(), *global::cout()); + auto fileEntries = MetalinkEntry::toFileEntry + (metalink::parseAndQuery(uri, op.get(), op->get(PREF_METALINK_BASE_URI))); + util::toStream(std::begin(fileEntries), std::end(fileEntries), + *global::cout()); global::cout()->write("\n"); global::cout()->flush(); } diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc index 2c37e300..0dd274e1 100644 --- a/src/DownloadContext.cc +++ b/src/DownloadContext.cc @@ -276,9 +276,9 @@ void DownloadContext::setBasePath(const std::string& basePath) basePath_ = basePath; } -void DownloadContext::setSignature(const std::shared_ptr<Signature>& signature) +void DownloadContext::setSignature(std::unique_ptr<Signature> signature) { - signature_ = signature; + signature_ = std::move(signature); } void DownloadContext::updateDownloadLength(size_t bytes) diff --git a/src/DownloadContext.h b/src/DownloadContext.h index 89a8c8e7..fe1e665a 100644 --- a/src/DownloadContext.h +++ b/src/DownloadContext.h @@ -84,7 +84,7 @@ private: Timer downloadStopTime_; - std::shared_ptr<Signature> signature_; + std::unique_ptr<Signature> signature_; // This member variable is required to avoid to use parse Metalink // (including both Metalink XML and Metalink/HTTP) twice. bool acceptMetalink_; @@ -169,9 +169,9 @@ public: void setBasePath(const std::string& basePath); - const std::shared_ptr<Signature>& getSignature() const { return signature_; } + const std::unique_ptr<Signature>& getSignature() const { return signature_; } - void setSignature(const std::shared_ptr<Signature>& signature); + void setSignature(std::unique_ptr<Signature> signature); RequestGroup* getOwnerRequestGroup() { return ownerRequestGroup_; } diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc index 0dd594f9..2a856bb9 100644 --- a/src/Metalink2RequestGroup.cc +++ b/src/Metalink2RequestGroup.cc @@ -58,6 +58,7 @@ #include "fmt.h" #include "SegList.h" #include "DownloadFailureException.h" +#include "Signature.h" #ifdef ENABLE_BITTORRENT # include "BtDependency.h" # include "download_helper.h" @@ -79,7 +80,7 @@ public: AccumulateNonP2PUri(std::vector<std::string>& urisPtr) :urisPtr(urisPtr) {} - void operator()(const std::shared_ptr<MetalinkResource>& resource) { + void operator()(const std::unique_ptr<MetalinkResource>& resource) { switch(resource->type) { case MetalinkResource::TYPE_HTTP: case MetalinkResource::TYPE_HTTPS: @@ -110,47 +111,51 @@ public: void Metalink2RequestGroup::generate -(std::vector<std::shared_ptr<RequestGroup> >& groups, +(std::vector<std::shared_ptr<RequestGroup>>& groups, const std::string& metalinkFile, const std::shared_ptr<Option>& option, const std::string& baseUri) { - std::vector<std::shared_ptr<MetalinkEntry> > entries; - metalink::parseAndQuery(entries, metalinkFile, option.get(), baseUri); - std::vector<std::shared_ptr<RequestGroup> > tempgroups; - createRequestGroup(tempgroups, entries, option); + std::vector<std::shared_ptr<RequestGroup>> tempgroups; + createRequestGroup(tempgroups, + metalink::parseAndQuery(metalinkFile, option.get(), + baseUri), + option); std::shared_ptr<MetadataInfo> mi; if(metalinkFile == DEV_STDIN) { - mi.reset(new MetadataInfo()); + mi = std::make_shared<MetadataInfo>(); } else { // TODO Downloads from local metalink file does not save neither // its gid nor MetadataInfo's gid. - mi.reset(new MetadataInfo(GroupId::create(), metalinkFile)); + mi = std::make_shared<MetadataInfo>(GroupId::create(), metalinkFile); } - setMetadataInfo(tempgroups.begin(), tempgroups.end(), mi); - groups.insert(groups.end(), tempgroups.begin(), tempgroups.end()); + setMetadataInfo(std::begin(tempgroups), std::end(tempgroups), mi); + groups.insert(std::end(groups), + std::begin(tempgroups), std::end(tempgroups)); } void Metalink2RequestGroup::generate -(std::vector<std::shared_ptr<RequestGroup> >& groups, +(std::vector<std::shared_ptr<RequestGroup>>& groups, const std::shared_ptr<BinaryStream>& binaryStream, const std::shared_ptr<Option>& option, const std::string& baseUri) { - std::vector<std::shared_ptr<MetalinkEntry> > entries; - metalink::parseAndQuery(entries, binaryStream.get(), option.get(), baseUri); - std::vector<std::shared_ptr<RequestGroup> > tempgroups; - createRequestGroup(tempgroups, entries, option); - std::shared_ptr<MetadataInfo> mi(new MetadataInfo()); - setMetadataInfo(tempgroups.begin(), tempgroups.end(), mi); - groups.insert(groups.end(), tempgroups.begin(), tempgroups.end()); + std::vector<std::shared_ptr<RequestGroup>> tempgroups; + createRequestGroup(tempgroups, + metalink::parseAndQuery(binaryStream.get(), option.get(), + baseUri), + option); + auto mi = std::make_shared<MetadataInfo>(); + setMetadataInfo(std::begin(tempgroups), std::end(tempgroups), mi); + groups.insert(std::end(groups), + std::begin(tempgroups), std::end(tempgroups)); } void Metalink2RequestGroup::createRequestGroup -(std::vector<std::shared_ptr<RequestGroup> >& groups, - const std::vector<std::shared_ptr<MetalinkEntry> >& entries, +(std::vector<std::shared_ptr<RequestGroup>>& groups, + std::vector<std::unique_ptr<MetalinkEntry>> entries, const std::shared_ptr<Option>& optionTemplate) { if(entries.empty()) { @@ -159,57 +164,52 @@ Metalink2RequestGroup::createRequestGroup } std::vector<std::string> locations; if(optionTemplate->defined(PREF_METALINK_LOCATION)) { - const std::string& loc = optionTemplate->get(PREF_METALINK_LOCATION); - util::split(loc.begin(), loc.end(), + auto& loc = optionTemplate->get(PREF_METALINK_LOCATION); + util::split(std::begin(loc), std::end(loc), std::back_inserter(locations), ',', true); - for(std::vector<std::string>::iterator i = locations.begin(), - eoi = locations.end(); i != eoi; ++i) { - util::lowercase(*i); + for(auto& s : locations) { + util::lowercase(s); } } std::string preferredProtocol; if(optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL) != V_NONE) { preferredProtocol = optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL); } - for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i = - entries.begin(), eoi = entries.end(); i != eoi; ++i) { - (*i)->dropUnsupportedResource(); - if((*i)->resources.empty() && (*i)->metaurls.empty()) { + for(auto& entry : entries) { + entry->dropUnsupportedResource(); + if(entry->resources.empty() && entry->metaurls.empty()) { continue; } - (*i)->setLocationPriority + entry->setLocationPriority (locations, -MetalinkResource::getLowestPriority()); if(!preferredProtocol.empty()) { - (*i)->setProtocolPriority + entry->setProtocolPriority (preferredProtocol, -MetalinkResource::getLowestPriority()); } } - std::vector<std::shared_ptr<MetalinkEntry> > selectedEntries; SegList<int> sgl; util::parseIntSegments(sgl, optionTemplate->get(PREF_SELECT_FILE)); sgl.normalize(); - if(!sgl.hasNext()) { - selectedEntries.assign(entries.begin(), entries.end()); - } else { - selectedEntries.reserve(entries.size()); + if(sgl.hasNext()) { + size_t inspoint = 0; for(size_t i = 0, len = entries.size(); i < len && sgl.hasNext(); ++i) { - size_t j = sgl.peek()-1; + size_t j = sgl.peek() - 1; if(i == j) { - selectedEntries.push_back(entries[i]); + if(inspoint != i) { + entries[inspoint] = std::move(entries[i]); + } + ++inspoint; sgl.next(); } } + entries.resize(inspoint); } - std::for_each(selectedEntries.begin(), selectedEntries.end(), + std::for_each(std::begin(entries), std::end(entries), std::mem_fn(&MetalinkEntry::reorderMetaurlsByPriority)); - std::vector<std::pair<std::string, - std::vector<std::shared_ptr<MetalinkEntry> > > > entryGroups; - metalink::groupEntryByMetaurlName(entryGroups, selectedEntries); - for(std::vector<std::pair<std::string, - std::vector<std::shared_ptr<MetalinkEntry> > > >::const_iterator itr = - entryGroups.begin(), eoi = entryGroups.end(); itr != eoi; ++itr) { - const std::string& metaurl = (*itr).first; - const std::vector<std::shared_ptr<MetalinkEntry> >& mes = (*itr).second; + auto entryGroups = metalink::groupEntryByMetaurlName(entries); + for(auto& entryGroup : entryGroups) { + auto& metaurl = entryGroup.first; + auto& mes = entryGroup.second; A2_LOG_INFO(fmt("Processing metaurl group metaurl=%s", metaurl.c_str())); #ifdef ENABLE_BITTORRENT std::shared_ptr<RequestGroup> torrentRg; @@ -217,7 +217,7 @@ Metalink2RequestGroup::createRequestGroup std::vector<std::string> uris; uris.push_back(metaurl); { - std::vector<std::shared_ptr<RequestGroup> > result; + std::vector<std::shared_ptr<RequestGroup>> result; createRequestGroupForUri(result, optionTemplate, uris, /* ignoreForceSequential = */true, /* ignoreLocalPath = */true); @@ -233,26 +233,24 @@ Metalink2RequestGroup::createRequestGroup // tranparent metalink torrentRg->getDownloadContext()->setAcceptMetalink(false); // make it in-memory download - std::shared_ptr<PreDownloadHandler> preh - (new MemoryBufferPreDownloadHandler()); - std::shared_ptr<RequestGroupCriteria> cri(new TrueRequestGroupCriteria()); - preh->setCriteria(cri); + auto preh = std::make_shared<MemoryBufferPreDownloadHandler>(); + preh->setCriteria(std::make_shared<TrueRequestGroupCriteria>()); torrentRg->addPreDownloadHandler(preh); groups.push_back(torrentRg); } } #endif // ENABLE_BITTORRENT - std::shared_ptr<Option> option = util::copy(optionTemplate); - std::shared_ptr<RequestGroup> rg(new RequestGroup(GroupId::create(), option)); + auto option = util::copy(optionTemplate); + auto rg = std::make_shared<RequestGroup>(GroupId::create(), option); std::shared_ptr<DownloadContext> dctx; int numSplit = option->getAsInt(PREF_SPLIT); int maxConn = option->getAsInt(PREF_MAX_CONNECTION_PER_SERVER); if(mes.size() == 1) { - std::shared_ptr<MetalinkEntry> entry = mes[0]; + auto entry = mes[0]; A2_LOG_INFO(fmt(MSG_METALINK_QUEUEING, entry->getPath().c_str())); entry->reorderResourcesByPriority(); std::vector<std::string> uris; - std::for_each(entry->resources.begin(), entry->resources.end(), + std::for_each(std::begin(entry->resources), std::end(entry->resources), AccumulateNonP2PUri(uris)); // If piece hash is specified in the metalink, // make segment size equal to piece hash size. @@ -266,11 +264,11 @@ Metalink2RequestGroup::createRequestGroup #else pieceLength = option->getAsInt(PREF_PIECE_LENGTH); #endif // ENABLE_MESSAGE_DIGEST - dctx.reset(new DownloadContext - (pieceLength, - entry->getLength(), - util::applyDir(option->get(PREF_DIR), - entry->file->getPath()))); + dctx = std::make_shared<DownloadContext> + (pieceLength, + entry->getLength(), + util::applyDir(option->get(PREF_DIR), + entry->file->getPath())); dctx->getFirstFileEntry()->setUris(uris); dctx->getFirstFileEntry()->setMaxConnectionPerServer(maxConn); if(option->getAsBool(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL)) { @@ -282,47 +280,49 @@ Metalink2RequestGroup::createRequestGroup entry->checksum->getDigest()); } if(entry->chunkChecksum) { - dctx->setPieceHashes(entry->chunkChecksum->getHashType(), - entry->chunkChecksum->getPieceHashes().begin(), - entry->chunkChecksum->getPieceHashes().end()); + dctx->setPieceHashes + (entry->chunkChecksum->getHashType(), + std::begin(entry->chunkChecksum->getPieceHashes()), + std::end(entry->chunkChecksum->getPieceHashes())); } #endif // ENABLE_MESSAGE_DIGEST - dctx->setSignature(entry->getSignature()); + dctx->setSignature(entry->popSignature()); rg->setNumConcurrentCommand (entry->maxConnections < 0 ? numSplit : std::min(numSplit, entry->maxConnections)); } else { - dctx.reset(new DownloadContext()); + dctx = std::make_shared<DownloadContext>(); // piece length is overridden by the one in torrent file. dctx->setPieceLength(option->getAsInt(PREF_PIECE_LENGTH)); - std::vector<std::shared_ptr<FileEntry> > fileEntries; + std::vector<std::shared_ptr<FileEntry>> fileEntries; int64_t offset = 0; - for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i = - mes.begin(), eoi = mes.end(); i != eoi; ++i) { + for(auto entry : mes) { A2_LOG_INFO(fmt("Metalink: Queueing %s for download as a member.", - (*i)->getPath().c_str())); - A2_LOG_DEBUG(fmt("originalName = %s", (*i)->metaurls[0]->name.c_str())); - (*i)->reorderResourcesByPriority(); + entry->getPath().c_str())); + A2_LOG_DEBUG(fmt("originalName = %s", + entry->metaurls[0]->name.c_str())); + entry->reorderResourcesByPriority(); std::vector<std::string> uris; - std::for_each((*i)->resources.begin(), (*i)->resources.end(), + std::for_each(std::begin(entry->resources), + std::end(entry->resources), AccumulateNonP2PUri(uris)); - std::shared_ptr<FileEntry> fe - (new FileEntry - (util::applyDir(option->get(PREF_DIR), (*i)->file->getPath()), - (*i)->file->getLength(), offset, uris)); + auto fe = std::make_shared<FileEntry> + (util::applyDir(option->get(PREF_DIR), + entry->file->getPath()), + entry->file->getLength(), offset, uris); fe->setMaxConnectionPerServer(maxConn); if(option->getAsBool(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL)) { fe->setUniqueProtocol(true); } - fe->setOriginalName((*i)->metaurls[0]->name); + fe->setOriginalName(entry->metaurls[0]->name); fileEntries.push_back(fe); if(offset > - std::numeric_limits<int64_t>::max() - (*i)->file->getLength()) { + std::numeric_limits<int64_t>::max() - entry->file->getLength()) { throw DOWNLOAD_FAILURE_EXCEPTION(fmt(EX_TOO_LARGE_FILE, offset)); } - offset += (*i)->file->getLength(); + offset += entry->file->getLength(); } - dctx->setFileEntries(fileEntries.begin(), fileEntries.end()); + dctx->setFileEntries(std::begin(fileEntries), std::end(fileEntries)); rg->setNumConcurrentCommand(numSplit); } rg->setDownloadContext(dctx); @@ -335,7 +335,7 @@ Metalink2RequestGroup::createRequestGroup // Inject depenency between rg and torrentRg here if // torrentRg is true if(torrentRg) { - std::shared_ptr<Dependency> dep(new BtDependency(rg.get(), torrentRg)); + auto dep = std::make_shared<BtDependency>(rg.get(), torrentRg); rg->dependsOn(dep); torrentRg->belongsTo(rg->getGID()); // metadata download may take very long time. If URIs are @@ -344,15 +344,14 @@ Metalink2RequestGroup::createRequestGroup time_t currentBtStopTimeout = torrentRg->getOption()->getAsInt(PREF_BT_STOP_TIMEOUT); if(currentBtStopTimeout == 0 || currentBtStopTimeout > btStopTimeout) { - std::vector<std::shared_ptr<FileEntry> >::const_iterator i; - std::vector<std::shared_ptr<FileEntry> >::const_iterator eoi - = dctx->getFileEntries().end(); - for(i = dctx->getFileEntries().begin(); i != eoi; ++i) { - if((*i)->getRemainingUris().empty()) { + bool allHaveUri = true; + for(auto& fe : dctx->getFileEntries()) { + if(fe->getRemainingUris().empty()) { + allHaveUri = false; break; } } - if(i == dctx->getFileEntries().end()) { + if(allHaveUri) { torrentRg->getOption()->put (PREF_BT_STOP_TIMEOUT, util::itos(btStopTimeout)); } diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h index 9b2574ac..a98e961f 100644 --- a/src/Metalink2RequestGroup.h +++ b/src/Metalink2RequestGroup.h @@ -52,18 +52,18 @@ class MetalinkEntry; class Metalink2RequestGroup { private: void - createRequestGroup(std::vector<std::shared_ptr<RequestGroup> >& groups, - const std::vector<std::shared_ptr<MetalinkEntry> >& entries, + createRequestGroup(std::vector<std::shared_ptr<RequestGroup>>& groups, + std::vector<std::unique_ptr<MetalinkEntry>> entries, const std::shared_ptr<Option>& option); public: Metalink2RequestGroup(); - void generate(std::vector<std::shared_ptr<RequestGroup> >& groups, + void generate(std::vector<std::shared_ptr<RequestGroup>>& groups, const std::string& metalinkFile, const std::shared_ptr<Option>& option, const std::string& baseUri = A2STR::NIL); - void generate(std::vector<std::shared_ptr<RequestGroup> >& groups, + void generate(std::vector<std::shared_ptr<RequestGroup>>& groups, const std::shared_ptr<BinaryStream>& binaryStream, const std::shared_ptr<Option>& option, const std::string& baseUri = A2STR::NIL); diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc index 86e47344..8decf8c2 100644 --- a/src/MetalinkEntry.cc +++ b/src/MetalinkEntry.cc @@ -57,45 +57,6 @@ MetalinkEntry::MetalinkEntry(): MetalinkEntry::~MetalinkEntry() {} -namespace { -class AddLocationPriority { -private: - std::vector<std::string> locations_; - int priorityToAdd_; -public: - AddLocationPriority - (const std::vector<std::string>& locations, int priorityToAdd): - locations_(locations), priorityToAdd_(priorityToAdd) - { - std::sort(locations_.begin(), locations_.end()); - } - - void operator()(std::shared_ptr<MetalinkResource>& res) { - if(std::binary_search - (locations_.begin(), locations_.end(), res->location)) { - res->priority += priorityToAdd_; - } - } -}; -} // namespace - -MetalinkEntry& MetalinkEntry::operator=(const MetalinkEntry& metalinkEntry) -{ - if(this != &metalinkEntry) { - this->file = metalinkEntry.file; - this->version = metalinkEntry.version; - this->languages = metalinkEntry.languages; - this->oses = metalinkEntry.oses; - this->maxConnections = metalinkEntry.maxConnections; -#ifdef ENABLE_MESSAGE_DIGEST - this->checksum = metalinkEntry.checksum; - this->chunkChecksum = metalinkEntry.chunkChecksum; -#endif // ENABLE_MESSAGE_DIGEST - this->signature_ = metalinkEntry.signature_; - } - return *this; -} - const std::string& MetalinkEntry::getPath() const { return file->getPath(); @@ -109,41 +70,29 @@ int64_t MetalinkEntry::getLength() const void MetalinkEntry::setLocationPriority (const std::vector<std::string>& locations, int priorityToAdd) { - std::for_each(resources.begin(), resources.end(), - AddLocationPriority(locations, priorityToAdd)); -} - -namespace { -class AddProtocolPriority { -private: - std::string protocol_; - int priorityToAdd_; -public: - AddProtocolPriority(const std::string& protocol, int prefToAdd): - protocol_(protocol), priorityToAdd_(prefToAdd) {} - - void operator()(const std::shared_ptr<MetalinkResource>& res) const - { - if(protocol_ == MetalinkResource::getTypeString(res->type)) { - res->priority += priorityToAdd_; + for(auto& res : resources) { + if(std::find(std::begin(locations), std::end(locations), res->location) + != std::end(locations)) { + res->priority += priorityToAdd; } } -}; -} // namespace +} void MetalinkEntry::setProtocolPriority(const std::string& protocol, - int priorityToAdd) + int priorityToAdd) { - std::for_each(resources.begin(), resources.end(), - AddProtocolPriority(protocol, priorityToAdd)); + for(auto& res : resources) { + if(protocol == MetalinkResource::getTypeString(res->type)) { + res->priority += priorityToAdd; + } + } } namespace { template<typename T> class PriorityHigher { public: - bool operator()(const std::shared_ptr<T>& res1, - const std::shared_ptr<T>& res2) + bool operator()(const T& res1, const T& res2) { return res1->priority < res2->priority; } @@ -151,15 +100,16 @@ public: } // namespace void MetalinkEntry::reorderResourcesByPriority() { - std::random_shuffle(resources.begin(), resources.end(), + std::random_shuffle(std::begin(resources), std::end(resources), *SimpleRandomizer::getInstance()); - std::sort(resources.begin(), resources.end(), - PriorityHigher<MetalinkResource>()); + std::sort(std::begin(resources), std::end(resources), + PriorityHigher<std::unique_ptr<MetalinkResource>>{}); } void MetalinkEntry::reorderMetaurlsByPriority() { - std::sort(metaurls.begin(), metaurls.end(),PriorityHigher<MetalinkMetaurl>()); + std::sort(std::begin(metaurls), std::end(metaurls), + PriorityHigher<std::unique_ptr<MetalinkMetaurl>>{}); } namespace { @@ -184,24 +134,43 @@ public: }; } // namespace -void MetalinkEntry::dropUnsupportedResource() { - resources.erase(std::remove_if(resources.begin(), resources.end(), - std::not1(Supported())), - resources.end()); +void MetalinkEntry::dropUnsupportedResource() +{ + resources.erase(std::remove_if + (std::begin(resources), std::end(resources), + [](const std::unique_ptr<MetalinkResource>& res) + { + switch(res->type) { + case MetalinkResource::TYPE_FTP: + case MetalinkResource::TYPE_HTTP: +#ifdef ENABLE_SSL + case MetalinkResource::TYPE_HTTPS: +#endif // ENABLE_SSL +#ifdef ENABLE_BITTORRENT + case MetalinkResource::TYPE_BITTORRENT: +#endif // ENABLE_BITTORRENT + return false; + default: + return true; + } + }), + std::end(resources)); } -void MetalinkEntry::toFileEntry -(std::vector<std::shared_ptr<FileEntry> >& fileEntries, - const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries) +std::vector<std::unique_ptr<FileEntry>> MetalinkEntry::toFileEntry +(std::vector<std::unique_ptr<MetalinkEntry>> metalinkEntries) { - std::transform(metalinkEntries.begin(), metalinkEntries.end(), - std::back_inserter(fileEntries), - std::mem_fn(&MetalinkEntry::getFile)); + std::vector<std::unique_ptr<FileEntry>> res; + res.reserve(metalinkEntries.size()); + for(auto& entry : metalinkEntries) { + res.push_back(entry->popFile()); + } + return res; } -void MetalinkEntry::setSignature(const std::shared_ptr<Signature>& signature) +void MetalinkEntry::setSignature(std::unique_ptr<Signature> signature) { - signature_ = signature; + signature_ = std::move(signature); } bool MetalinkEntry::containsLanguage(const std::string& lang) const @@ -214,4 +183,14 @@ bool MetalinkEntry::containsOS(const std::string& os) const return std::find(oses.begin(), oses.end(), os) != oses.end(); } +std::unique_ptr<Signature> MetalinkEntry::popSignature() +{ + return std::move(signature_); +} + +std::unique_ptr<FileEntry> MetalinkEntry::popFile() +{ + return std::move(file); +} + } // namespace aria2 diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h index 475efe0d..8884ee7f 100644 --- a/src/MetalinkEntry.h +++ b/src/MetalinkEntry.h @@ -54,37 +54,37 @@ class Signature; class MetalinkEntry { public: - std::shared_ptr<FileEntry> file; + std::unique_ptr<FileEntry> file; std::string version; std::vector<std::string> languages; std::vector<std::string> oses; // True if size is specified in Metalink document. bool sizeKnown; - std::vector<std::shared_ptr<MetalinkResource> > resources; - std::vector<std::shared_ptr<MetalinkMetaurl> > metaurls; + std::vector<std::unique_ptr<MetalinkResource>> resources; + std::vector<std::unique_ptr<MetalinkMetaurl>> metaurls; int maxConnections; // Metalink3Spec #ifdef ENABLE_MESSAGE_DIGEST - std::shared_ptr<Checksum> checksum; - std::shared_ptr<ChunkChecksum> chunkChecksum; + std::unique_ptr<Checksum> checksum; + std::unique_ptr<ChunkChecksum> chunkChecksum; #endif // ENABLE_MESSAGE_DIGEST private: - std::shared_ptr<Signature> signature_; + std::unique_ptr<Signature> signature_; public: MetalinkEntry(); ~MetalinkEntry(); - MetalinkEntry& operator=(const MetalinkEntry& metalinkEntry); - const std::string& getPath() const; int64_t getLength() const; - const std::shared_ptr<FileEntry>& getFile() const + const std::unique_ptr<FileEntry>& getFile() const { return file; } + std::unique_ptr<FileEntry> popFile(); + void dropUnsupportedResource(); void reorderResourcesByPriority(); @@ -100,16 +100,17 @@ public: void setProtocolPriority(const std::string& protocol, int priorityToAdd); - static void toFileEntry - (std::vector<std::shared_ptr<FileEntry> >& fileEntries, - const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries); + static std::vector<std::unique_ptr<FileEntry>> toFileEntry + (std::vector<std::unique_ptr<MetalinkEntry>> metalinkEntries); - void setSignature(const std::shared_ptr<Signature>& signature); + void setSignature(std::unique_ptr<Signature> signature); - const std::shared_ptr<Signature>& getSignature() const + const std::unique_ptr<Signature>& getSignature() const { return signature_; } + + std::unique_ptr<Signature> popSignature(); }; } // namespace aria2 diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc index 00ddbbb9..5ae75845 100644 --- a/src/MetalinkParserController.cc +++ b/src/MetalinkParserController.cc @@ -57,20 +57,25 @@ namespace aria2 { -MetalinkParserController::MetalinkParserController(): - metalinker_(new Metalinker()) +MetalinkParserController::MetalinkParserController() + : metalinker_{make_unique<Metalinker>()} {} MetalinkParserController::~MetalinkParserController() {} void MetalinkParserController::reset() { - metalinker_.reset(new Metalinker()); + metalinker_ = make_unique<Metalinker>(); +} + +std::unique_ptr<Metalinker> MetalinkParserController::getResult() +{ + return std::move(metalinker_); } void MetalinkParserController::newEntryTransaction() { - tEntry_.reset(new MetalinkEntry()); + tEntry_ = make_unique<MetalinkEntry>(); tResource_.reset(); tMetaurl_.reset(); #ifdef ENABLE_MESSAGE_DIGEST @@ -86,7 +91,7 @@ void MetalinkParserController::setFileNameOfEntry(const std::string& filename) return; } if(!tEntry_->file) { - tEntry_->file.reset(new FileEntry(util::escapePath(filename), 0, 0)); + tEntry_->file = make_unique<FileEntry>(util::escapePath(filename), 0, 0); } else { tEntry_->file->setPath(util::escapePath(filename)); } @@ -147,8 +152,7 @@ void MetalinkParserController::commitEntryTransaction() commitChunkChecksumTransactionV4(); commitChunkChecksumTransaction(); commitSignatureTransaction(); - metalinker_->addEntry(tEntry_); - tEntry_.reset(); + metalinker_->addEntry(std::move(tEntry_)); } void MetalinkParserController::cancelEntryTransaction() @@ -167,7 +171,7 @@ void MetalinkParserController::newResourceTransaction() if(!tEntry_) { return; } - tResource_.reset(new MetalinkResource()); + tResource_ = make_unique<MetalinkResource>(); } void MetalinkParserController::setURLOfResource(const std::string& url) @@ -237,16 +241,16 @@ void MetalinkParserController::commitResourceTransaction() } #ifdef ENABLE_BITTORRENT if(tResource_->type == MetalinkResource::TYPE_BITTORRENT) { - std::shared_ptr<MetalinkMetaurl> metaurl(new MetalinkMetaurl()); - metaurl->url = tResource_->url; + auto metaurl = make_unique<MetalinkMetaurl>(); + metaurl->url = std::move(tResource_->url); metaurl->priority = tResource_->priority; metaurl->mediatype = MetalinkMetaurl::MEDIATYPE_TORRENT; - tEntry_->metaurls.push_back(metaurl); + tEntry_->metaurls.push_back(std::move(metaurl)); } else { - tEntry_->resources.push_back(tResource_); + tEntry_->resources.push_back(std::move(tResource_)); } #else // !ENABLE_BITTORRENT - tEntry_->resources.push_back(tResource_); + tEntry_->resources.push_back(std::move(tResource_)); #endif // !ENABLE_BITTORRENT tResource_.reset(); } @@ -262,7 +266,7 @@ void MetalinkParserController::newChecksumTransaction() if(!tEntry_) { return; } - tChecksum_.reset(new Checksum()); + tChecksum_ = make_unique<Checksum>(); #endif // ENABLE_MESSAGE_DIGEST } @@ -304,7 +308,7 @@ void MetalinkParserController::commitChecksumTransaction() if(!tEntry_->checksum || MessageDigest::isStronger(tChecksum_->getHashType(), tEntry_->checksum->getHashType())) { - tEntry_->checksum = tChecksum_; + tEntry_->checksum = std::move(tChecksum_); } tChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST @@ -323,7 +327,7 @@ void MetalinkParserController::newChunkChecksumTransactionV4() if(!tEntry_) { return; } - tChunkChecksumV4_.reset(new ChunkChecksum()); + tChunkChecksumV4_ = make_unique<ChunkChecksum>(); tempChunkChecksumsV4_.clear(); #endif // ENABLE_MESSAGE_DIGEST } @@ -380,10 +384,8 @@ void MetalinkParserController::commitChunkChecksumTransactionV4() if(!tEntry_->chunkChecksum || MessageDigest::isStronger(tChunkChecksumV4_->getHashType(), tEntry_->chunkChecksum->getHashType())) { - std::vector<std::string> pieceHashes(tempChunkChecksumsV4_.begin(), - tempChunkChecksumsV4_.end()); - tChunkChecksumV4_->setPieceHashes(pieceHashes); - tEntry_->chunkChecksum = tChunkChecksumV4_; + tChunkChecksumV4_->setPieceHashes(std::move(tempChunkChecksumsV4_)); + tEntry_->chunkChecksum = std::move(tChunkChecksumV4_); } tChunkChecksumV4_.reset(); #endif // ENABLE_MESSAGE_DIGEST @@ -402,7 +404,7 @@ void MetalinkParserController::newChunkChecksumTransaction() if(!tEntry_) { return; } - tChunkChecksum_.reset(new ChunkChecksum()); + tChunkChecksum_ = make_unique<ChunkChecksum>(); tempChunkChecksums_.clear(); #endif // ENABLE_MESSAGE_DIGEST } @@ -493,14 +495,15 @@ void MetalinkParserController::commitChunkChecksumTransaction() if(!tEntry_->chunkChecksum || MessageDigest::isStronger(tChunkChecksum_->getHashType(), tEntry_->chunkChecksum->getHashType())) { - std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end()); + std::sort(std::begin(tempChunkChecksums_), std::end(tempChunkChecksums_)); std::vector<std::string> pieceHashes; - std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(), + std::transform(std::begin(tempChunkChecksums_), + std::end(tempChunkChecksums_), std::back_inserter(pieceHashes), [](const std::pair<size_t, std::string>& p) { return p.second; }); - tChunkChecksum_->setPieceHashes(pieceHashes); - tEntry_->chunkChecksum = tChunkChecksum_; + tChunkChecksum_->setPieceHashes(std::move(pieceHashes)); + tEntry_->chunkChecksum = std::move(tChunkChecksum_); } tChunkChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST @@ -518,7 +521,7 @@ void MetalinkParserController::newSignatureTransaction() if(!tEntry_) { return; } - tSignature_.reset(new Signature()); + tSignature_ = make_unique<Signature>(); } void MetalinkParserController::setTypeOfSignature(const std::string& type) @@ -550,8 +553,7 @@ void MetalinkParserController::commitSignatureTransaction() if(!tSignature_) { return; } - tEntry_->setSignature(tSignature_); - tSignature_.reset(); + tEntry_->setSignature(std::move(tSignature_)); } void MetalinkParserController::cancelSignatureTransaction() @@ -564,7 +566,7 @@ void MetalinkParserController::newMetaurlTransaction() if(!tEntry_) { return; } - tMetaurl_.reset(new MetalinkMetaurl()); + tMetaurl_ = make_unique<MetalinkMetaurl>(); } void MetalinkParserController::setURLOfMetaurl(const std::string& url) @@ -619,7 +621,7 @@ void MetalinkParserController::commitMetaurlTransaction() } #ifdef ENABLE_BITTORRENT if(tMetaurl_->mediatype == MetalinkMetaurl::MEDIATYPE_TORRENT) { - tEntry_->metaurls.push_back(tMetaurl_); + tEntry_->metaurls.push_back(std::move(tMetaurl_)); } #endif // ENABLE_BITTORRENT tMetaurl_.reset(); diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h index c3bd537a..12fd6f4f 100644 --- a/src/MetalinkParserController.h +++ b/src/MetalinkParserController.h @@ -57,21 +57,21 @@ class ChunkChecksum; class MetalinkParserController { private: - std::shared_ptr<Metalinker> metalinker_; + std::unique_ptr<Metalinker> metalinker_; - std::shared_ptr<MetalinkEntry> tEntry_; + std::unique_ptr<MetalinkEntry> tEntry_; - std::shared_ptr<MetalinkResource> tResource_; + std::unique_ptr<MetalinkResource> tResource_; - std::shared_ptr<MetalinkMetaurl> tMetaurl_; + std::unique_ptr<MetalinkMetaurl> tMetaurl_; #ifdef ENABLE_MESSAGE_DIGEST - std::shared_ptr<Checksum> tChecksum_; + std::unique_ptr<Checksum> tChecksum_; - std::shared_ptr<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec + std::unique_ptr<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec std::vector<std::string> tempChunkChecksumsV4_; // Metalink4Spec - std::shared_ptr<ChunkChecksum> tChunkChecksum_; // Metalink3Spec + std::unique_ptr<ChunkChecksum> tChunkChecksum_; // Metalink3Spec std::vector<std::pair<size_t, std::string> > tempChunkChecksums_;//Metalink3Spec @@ -79,7 +79,7 @@ private: #endif // ENABLE_MESSAGE_DIGEST - std::shared_ptr<Signature> tSignature_; + std::unique_ptr<Signature> tSignature_; std::string baseUri_; public: MetalinkParserController(); @@ -88,10 +88,7 @@ public: void reset(); - const std::shared_ptr<Metalinker>& getResult() const - { - return metalinker_; - } + std::unique_ptr<Metalinker> getResult(); void newEntryTransaction(); diff --git a/src/MetalinkParserStateMachine.cc b/src/MetalinkParserStateMachine.cc index bcca4410..2f4fd242 100644 --- a/src/MetalinkParserStateMachine.cc +++ b/src/MetalinkParserStateMachine.cc @@ -42,6 +42,7 @@ #include "MetalinkParserStateV4Impl.h" #include "Metalinker.h" #include "MetalinkEntry.h" +#include "a2functional.h" namespace aria2 { @@ -104,8 +105,8 @@ MetalinkParserState* MetalinkParserStateMachine::urlStateV4_ = MetalinkParserState* MetalinkParserStateMachine::metaurlStateV4_ = new MetaurlMetalinkParserStateV4(); -MetalinkParserStateMachine::MetalinkParserStateMachine(): - ctrl_(new MetalinkParserController()) +MetalinkParserStateMachine::MetalinkParserStateMachine() + : ctrl_{make_unique<MetalinkParserController>()} { stateStack_.push(initialState_); } @@ -551,6 +552,11 @@ std::string MetalinkParserStateMachine::getErrorString() const return error.str(); } +std::unique_ptr<Metalinker> MetalinkParserStateMachine::getResult() +{ + return ctrl_->getResult(); +} + void MetalinkParserStateMachine::setBaseUri(const std::string& uri) { ctrl_->setBaseUri(uri); diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h index 13b6581c..ad7c1456 100644 --- a/src/MetalinkParserStateMachine.h +++ b/src/MetalinkParserStateMachine.h @@ -51,7 +51,7 @@ class Metalinker; class MetalinkParserStateMachine : public ParserStateMachine { private: - std::shared_ptr<MetalinkParserController> ctrl_; + std::unique_ptr<MetalinkParserController> ctrl_; std::stack<MetalinkParserState*> stateStack_; @@ -265,10 +265,7 @@ public: std::string getErrorString() const; - const std::shared_ptr<Metalinker>& getResult() const - { - return ctrl_->getResult(); - } + std::unique_ptr<Metalinker> getResult(); void setBaseUri(const std::string& uri); }; diff --git a/src/MetalinkResource.h b/src/MetalinkResource.h index d4d53944..725a5c16 100644 --- a/src/MetalinkResource.h +++ b/src/MetalinkResource.h @@ -63,8 +63,8 @@ public: ~MetalinkResource(); // Don't allow copying - MetalinkResource(const MetalinkResource&); - MetalinkResource& operator=(const MetalinkResource&); + MetalinkResource(const MetalinkResource&) = delete; + MetalinkResource& operator=(const MetalinkResource&) = delete; static const std::string& getTypeString(TYPE type) { diff --git a/src/Metalinker.cc b/src/Metalinker.cc index 70e8fcfa..91bb145e 100644 --- a/src/Metalinker.cc +++ b/src/Metalinker.cc @@ -43,56 +43,32 @@ Metalinker::Metalinker() {} Metalinker::~Metalinker() {} -namespace { -class EntryQuery: - public std::unary_function<std::shared_ptr<MetalinkEntry>, bool> { -private: - std::string version; - std::string language; - std::string os; -public: - EntryQuery(const std::string& version, - const std::string& language, - const std::string& os): - version(version), - language(language), - os(os) {} - - bool operator()(const std::shared_ptr<MetalinkEntry>& entry) const { - if(!version.empty()) { - if(version != entry->version) { - return false; - } - } - if(!language.empty()) { - if(!entry->containsLanguage(language)) { - return false; - } - } - if(!os.empty()) { - if(!entry->containsOS(os)) { - return false; - } +std::vector<std::unique_ptr<MetalinkEntry>> +Metalinker::queryEntry(const std::string& version, + const std::string& language, + const std::string& os) +{ + std::vector<std::unique_ptr<MetalinkEntry>> res; + for(auto& entry : entries_) { + if((!version.empty() && version != entry->version) || + (!language.empty() && !entry->containsLanguage(language)) || + (!os.empty() && !entry->containsOS(os))) { + continue; } - return true; + res.push_back(std::move(entry)); } -}; -} // namespace - -void Metalinker::queryEntry -(std::vector<std::shared_ptr<MetalinkEntry> >& queryResult, - const std::string& version, - const std::string& language, - const std::string& os) const -{ - std::remove_copy_if(entries_.begin(), entries_.end(), - std::back_inserter(queryResult), - std::not1(EntryQuery(version, language, os))); + entries_.erase(std::remove_if(std::begin(entries_), std::end(entries_), + [](const std::unique_ptr<MetalinkEntry>& entry) + { + return !entry.get(); + }), + std::end(entries_)); + return res; } -void Metalinker::addEntry(const std::shared_ptr<MetalinkEntry>& entry) +void Metalinker::addEntry(std::unique_ptr<MetalinkEntry> entry) { - entries_.push_back(entry); + entries_.push_back(std::move(entry)); } } // namespace aria2 diff --git a/src/Metalinker.h b/src/Metalinker.h index 6e2726d9..4fc61c33 100644 --- a/src/Metalinker.h +++ b/src/Metalinker.h @@ -47,27 +47,26 @@ class MetalinkEntry; class Metalinker { private: - std::vector<std::shared_ptr<MetalinkEntry> > entries_; + std::vector<std::unique_ptr<MetalinkEntry>> entries_; public: Metalinker(); ~Metalinker(); // Don't allow copying - Metalinker(const Metalinker&); - Metalinker& operator=(const Metalinker&); + Metalinker(const Metalinker&) = delete; + Metalinker& operator=(const Metalinker&) = delete; - void queryEntry - (std::vector<std::shared_ptr<MetalinkEntry> >& queryResult, - const std::string& version, - const std::string& language, - const std::string& os) const; + std::vector<std::unique_ptr<MetalinkEntry>> + queryEntry(const std::string& version, + const std::string& language, + const std::string& os); - const std::vector<std::shared_ptr<MetalinkEntry> >& getEntries() const + const std::vector<std::unique_ptr<MetalinkEntry>>& getEntries() const { return entries_; } - void addEntry(const std::shared_ptr<MetalinkEntry>& entry); + void addEntry(std::unique_ptr<MetalinkEntry> entry); }; } // namespace aria2 diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc index 933f3807..6cae6b34 100644 --- a/src/RequestGroupMan.cc +++ b/src/RequestGroupMan.cc @@ -257,8 +257,7 @@ private: void saveSignature(const std::shared_ptr<RequestGroup>& group) { - std::shared_ptr<Signature> sig = - group->getDownloadContext()->getSignature(); + auto& sig = group->getDownloadContext()->getSignature(); if(sig && !sig->getBody().empty()) { // filename of signature file is the path to download file followed by // ".sig". diff --git a/src/metalink_helper.cc b/src/metalink_helper.cc index 3f70ae5f..bebbc0f7 100644 --- a/src/metalink_helper.cc +++ b/src/metalink_helper.cc @@ -49,77 +49,65 @@ namespace metalink { namespace { -void query -(std::vector<std::shared_ptr<MetalinkEntry> >& result, - const std::shared_ptr<Metalinker>& metalinker, - const Option* option) +std::vector<std::unique_ptr<MetalinkEntry>> +query(const std::shared_ptr<Metalinker>& metalinker, + const Option* option) { - metalinker->queryEntry(result, - option->get(PREF_METALINK_VERSION), - option->get(PREF_METALINK_LANGUAGE), - option->get(PREF_METALINK_OS)); + return metalinker->queryEntry(option->get(PREF_METALINK_VERSION), + option->get(PREF_METALINK_LANGUAGE), + option->get(PREF_METALINK_OS)); } } // namespace -void parseAndQuery -(std::vector<std::shared_ptr<MetalinkEntry> >& result, - const std::string& filename, +std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery +(const std::string& filename, const Option* option, const std::string& baseUri) { - std::shared_ptr<Metalinker> metalinker = parseFile(filename, baseUri); - query(result, metalinker, option); + return query(parseFile(filename, baseUri), option); } -void parseAndQuery -(std::vector<std::shared_ptr<MetalinkEntry> >& result, - BinaryStream* bs, +std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery +(BinaryStream* bs, const Option* option, const std::string& baseUri) { - std::shared_ptr<Metalinker> metalinker = parseBinaryStream(bs, baseUri); - query(result, metalinker, option); + return query(parseBinaryStream(bs, baseUri), option); } -void groupEntryByMetaurlName -(std::vector< - std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result, - const std::vector<std::shared_ptr<MetalinkEntry> >& entries) +std::vector<std::pair<std::string, + std::vector<MetalinkEntry*>>> groupEntryByMetaurlName +(const std::vector<std::unique_ptr<MetalinkEntry>>& entries) { - for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator eiter = - entries.begin(), eoi = entries.end(); eiter != eoi; ++eiter) { - if((*eiter)->metaurls.empty()) { - std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p; - p.second.push_back(*eiter); - result.push_back(p); + std::vector<std::pair<std::string, + std::vector<MetalinkEntry*>>> result; + for(auto& entry : entries) { + if(entry->metaurls.empty()) { + // std::pair<std::string, std::vector<MetalinkEntry*>> p; + // p.second.push_back(entry.get()); + result.push_back({"", {entry.get()}}); } else { - std::vector< - std::pair<std::string, - std::vector<std::shared_ptr<MetalinkEntry> > > >::iterator i = - result.begin(); - if((*eiter)->metaurls[0]->name.empty() || - !(*eiter)->sizeKnown) { - i = result.end(); + auto i = std::begin(result); + if(entry->metaurls[0]->name.empty() || !entry->sizeKnown) { + i = std::end(result); } - for(; i != result.end(); ++i) { - if((*i).first == (*eiter)->metaurls[0]->url && + for(; i != std::end(result); ++i) { + if((*i).first == entry->metaurls[0]->url && !(*i).second[0]->metaurls[0]->name.empty()) { - (*i).second.push_back(*eiter); + (*i).second.push_back(entry.get()); break; } } - if(i == result.end()) { - std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p; - p.first = (*eiter)->metaurls[0]->url; - p.second.push_back(*eiter); - result.push_back(p); + if(i == std::end(result)) { + result.push_back({entry->metaurls[0]->url, {entry.get()}}); } } } + return result; } -std::shared_ptr<Metalinker> parseFile +std::unique_ptr<Metalinker> parseFile (const std::string& filename, const std::string& baseUri) { @@ -136,7 +124,7 @@ std::shared_ptr<Metalinker> parseFile return psm.getResult(); } -std::shared_ptr<Metalinker> parseBinaryStream +std::unique_ptr<Metalinker> parseBinaryStream (BinaryStream* bs, const std::string& baseUri) { diff --git a/src/metalink_helper.h b/src/metalink_helper.h index 875733be..495ac70e 100644 --- a/src/metalink_helper.h +++ b/src/metalink_helper.h @@ -52,28 +52,25 @@ class Metalinker; namespace metalink { -void parseAndQuery -(std::vector<std::shared_ptr<MetalinkEntry> >& result, - const std::string& filename, +std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery +(const std::string& filename, const Option* option, const std::string& baseUri = A2STR::NIL); -void parseAndQuery -(std::vector<std::shared_ptr<MetalinkEntry> >& result, - BinaryStream* bs, +std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery +(BinaryStream* bs, const Option* option, const std::string& baseUri = A2STR::NIL); -void groupEntryByMetaurlName -(std::vector< - std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result, - const std::vector<std::shared_ptr<MetalinkEntry> >& entries); +std::vector<std::pair<std::string, + std::vector<MetalinkEntry*>>> groupEntryByMetaurlName +(const std::vector<std::unique_ptr<MetalinkEntry>>& entries); -std::shared_ptr<Metalinker> parseFile +std::unique_ptr<Metalinker> parseFile (const std::string& filename, const std::string& baseUri = A2STR::NIL); -std::shared_ptr<Metalinker> parseBinaryStream +std::unique_ptr<Metalinker> parseBinaryStream (BinaryStream* bs, const std::string& baseUri = A2STR::NIL); diff --git a/test/MetalinkEntryTest.cc b/test/MetalinkEntryTest.cc index 611d9dbe..27122d56 100644 --- a/test/MetalinkEntryTest.cc +++ b/test/MetalinkEntryTest.cc @@ -3,6 +3,7 @@ #include <cppunit/extensions/HelperMacros.h> #include "MetalinkResource.h" +#include "a2functional.h" namespace aria2 { @@ -31,44 +32,46 @@ public: CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkEntryTest ); -std::shared_ptr<MetalinkEntry> createTestEntry() { - std::shared_ptr<MetalinkEntry> entry(new MetalinkEntry()); - std::shared_ptr<MetalinkResource> res1(new MetalinkResource()); +std::unique_ptr<MetalinkEntry> createTestEntry() +{ + auto entry = make_unique<MetalinkEntry>(); + auto res1 = make_unique<MetalinkResource>(); res1->url = "ftp://myhost/aria2.tar.bz2"; res1->type = MetalinkResource::TYPE_FTP; res1->location = "ro"; res1->priority = 50; - std::shared_ptr<MetalinkResource> res2(new MetalinkResource()); + auto res2 = make_unique<MetalinkResource>(); res2->url = "http://myhost/aria2.tar.bz2"; res2->type = MetalinkResource::TYPE_HTTP; res2->location = "at"; res2->priority = 1; - std::shared_ptr<MetalinkResource> res3(new MetalinkResource()); + auto res3 = make_unique<MetalinkResource>(); res3->url = "http://myhost/aria2.torrent"; res3->type = MetalinkResource::TYPE_BITTORRENT; res3->location = "al"; res3->priority = 40; - std::shared_ptr<MetalinkResource> res4(new MetalinkResource()); + auto res4 = make_unique<MetalinkResource>(); res4->url = "http://myhost/aria2.ext"; res4->type = MetalinkResource::TYPE_NOT_SUPPORTED; res4->location = "ad"; res4->priority = 90; - std::shared_ptr<MetalinkResource> res5(new MetalinkResource()); + auto res5 = make_unique<MetalinkResource>(); res5->url = "https://myhost/aria2.tar.bz2"; res5->type = MetalinkResource::TYPE_HTTPS; res5->location = "jp"; res5->priority = 10; - entry->resources.push_back(res1); - entry->resources.push_back(res2); - entry->resources.push_back(res3); - entry->resources.push_back(res4); - entry->resources.push_back(res5); + entry->resources.push_back(std::move(res1)); + entry->resources.push_back(std::move(res2)); + entry->resources.push_back(std::move(res3)); + entry->resources.push_back(std::move(res4)); + entry->resources.push_back(std::move(res5)); return entry; } -void MetalinkEntryTest::testDropUnsupportedResource() { - std::shared_ptr<MetalinkEntry> entry(createTestEntry()); +void MetalinkEntryTest::testDropUnsupportedResource() +{ + auto entry = createTestEntry(); entry->dropUnsupportedResource(); #if defined ENABLE_SSL && defined ENABLE_BITTORRENT @@ -79,8 +82,7 @@ void MetalinkEntryTest::testDropUnsupportedResource() { CPPUNIT_ASSERT_EQUAL((size_t)2, entry->resources.size()); #endif // ENABLE_MESSAGE_DIGEST - std::vector<std::shared_ptr<MetalinkResource> >::const_iterator itr = - entry->resources.begin(); + auto itr = std::begin(entry->resources); CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, (*itr++)->type); CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, @@ -95,8 +97,9 @@ void MetalinkEntryTest::testDropUnsupportedResource() { #endif // ENABLE_SSL } -void MetalinkEntryTest::testReorderResourcesByPriority() { - std::shared_ptr<MetalinkEntry> entry(createTestEntry()); +void MetalinkEntryTest::testReorderResourcesByPriority() +{ + auto entry = createTestEntry(); entry->reorderResourcesByPriority(); @@ -109,11 +112,9 @@ void MetalinkEntryTest::testReorderResourcesByPriority() { void MetalinkEntryTest::testSetLocationPriority() { - std::shared_ptr<MetalinkEntry> entry(createTestEntry()); - - const char* locationsSrc[] = { "jp", "al", "ro" }; + auto entry = createTestEntry(); - std::vector<std::string> locations(&locationsSrc[0], &locationsSrc[3]); + auto locations = std::vector<std::string>{ "jp", "al", "ro" }; entry->setLocationPriority(locations, -100); @@ -131,7 +132,7 @@ void MetalinkEntryTest::testSetLocationPriority() void MetalinkEntryTest::testSetProtocolPriority() { - std::shared_ptr<MetalinkEntry> entry(createTestEntry()); + auto entry = createTestEntry(); entry->setProtocolPriority("http", -1); CPPUNIT_ASSERT_EQUAL(50, entry->resources[0]->priority); // ftp CPPUNIT_ASSERT_EQUAL(0, entry->resources[1]->priority); // http, -1 diff --git a/test/MetalinkHelperTest.cc b/test/MetalinkHelperTest.cc index 7fd78b5d..9d0bc1d8 100644 --- a/test/MetalinkHelperTest.cc +++ b/test/MetalinkHelperTest.cc @@ -6,6 +6,7 @@ #include "Option.h" #include "prefs.h" #include "MetalinkMetaurl.h" +#include "a2functional.h" namespace aria2 { @@ -30,8 +31,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkHelperTest ); void MetalinkHelperTest::testParseAndQuery() { Option option; - std::vector<std::shared_ptr<MetalinkEntry> > result; - metalink::parseAndQuery(result, A2_TEST_DIR"/test.xml", &option); + auto result = metalink::parseAndQuery(A2_TEST_DIR"/test.xml", &option); CPPUNIT_ASSERT_EQUAL((size_t)5, result.size()); } @@ -39,67 +39,59 @@ void MetalinkHelperTest::testParseAndQuery_version() { Option option; option.put(PREF_METALINK_VERSION, "0.5.1"); - std::vector<std::shared_ptr<MetalinkEntry> > result; - metalink::parseAndQuery(result, A2_TEST_DIR"/test.xml", &option); + auto result = metalink::parseAndQuery(A2_TEST_DIR"/test.xml", &option); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); - std::shared_ptr<MetalinkEntry> entry = result.front(); + auto& entry = result.front(); CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry->getPath()); } void MetalinkHelperTest::testGroupEntryByMetaurlName() { - std::vector<std::shared_ptr<MetalinkEntry> > entries; + std::vector<std::unique_ptr<MetalinkEntry>> entries; - std::shared_ptr<MetalinkEntry> e1(new MetalinkEntry()); + auto e1 = make_unique<MetalinkEntry>(); e1->version = "1"; e1->sizeKnown = true; // no name e1->metaurls.push_back - (std::shared_ptr<MetalinkMetaurl> - (new MetalinkMetaurl("http://meta1", "torrent", "", 1))); + (make_unique<MetalinkMetaurl>("http://meta1", "torrent", "", 1)); - std::shared_ptr<MetalinkEntry> e2(new MetalinkEntry()); + auto e2 = make_unique<MetalinkEntry>(); e2->version = "2"; e2->sizeKnown = true; - std::shared_ptr<MetalinkEntry> e3(new MetalinkEntry()); + auto e3 = make_unique<MetalinkEntry>(); e3->version = "3"; e3->sizeKnown = true; e3->metaurls.push_back - (std::shared_ptr<MetalinkMetaurl> - (new MetalinkMetaurl("http://meta2", "torrent", "f3", 1))); + (make_unique<MetalinkMetaurl>("http://meta2", "torrent", "f3", 1)); - std::shared_ptr<MetalinkEntry> e4(new MetalinkEntry()); + auto e4 = make_unique<MetalinkEntry>(); e4->version = "4"; e4->sizeKnown = true; e4->metaurls.push_back - (std::shared_ptr<MetalinkMetaurl> - (new MetalinkMetaurl("http://meta1", "torrent", "f4", 1))); + (make_unique<MetalinkMetaurl>("http://meta1", "torrent", "f4", 1)); - std::shared_ptr<MetalinkEntry> e5(new MetalinkEntry()); + auto e5 = make_unique<MetalinkEntry>(); e5->version = "5"; // no size e5->metaurls.push_back - (std::shared_ptr<MetalinkMetaurl> - (new MetalinkMetaurl("http://meta1", "torrent", "f5", 1))); + (make_unique<MetalinkMetaurl>("http://meta1", "torrent", "f5", 1)); - std::shared_ptr<MetalinkEntry> e6(new MetalinkEntry()); + auto e6 = make_unique<MetalinkEntry>(); e6->version = "6"; e6->sizeKnown = true; e6->metaurls.push_back - (std::shared_ptr<MetalinkMetaurl> - (new MetalinkMetaurl("http://meta1", "torrent", "f6", 1))); - - entries.push_back(e1); - entries.push_back(e2); - entries.push_back(e3); - entries.push_back(e4); - entries.push_back(e5); - entries.push_back(e6); - - std::vector<std::pair<std::string, - std::vector<std::shared_ptr<MetalinkEntry> > > > result; - metalink::groupEntryByMetaurlName(result, entries); + (make_unique<MetalinkMetaurl>("http://meta1", "torrent", "f6", 1)); + + entries.push_back(std::move(e1)); + entries.push_back(std::move(e2)); + entries.push_back(std::move(e3)); + entries.push_back(std::move(e4)); + entries.push_back(std::move(e5)); + entries.push_back(std::move(e6)); + + auto result = metalink::groupEntryByMetaurlName(entries); CPPUNIT_ASSERT_EQUAL(std::string("http://meta1"), result[0].first); CPPUNIT_ASSERT_EQUAL(std::string("1"), result[0].second[0]->version); diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc index 50829cb9..a6c921d0 100644 --- a/test/MetalinkParserControllerTest.cc +++ b/test/MetalinkParserControllerTest.cc @@ -63,10 +63,12 @@ void MetalinkParserControllerTest::testEntryTransaction() ctrl.setLanguageOfEntry("ja_JP"); ctrl.setOSOfEntry("Linux"); ctrl.commitEntryTransaction(); + ctrl.newEntryTransaction(); + ctrl.cancelEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); + auto m = ctrl.getResult(); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - std::shared_ptr<MetalinkEntry> e = m->getEntries().front(); + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath()); CPPUNIT_ASSERT_EQUAL((int64_t)(1024*1024LL), e->file->getLength()); CPPUNIT_ASSERT_EQUAL((int64_t)0, e->file->getOffset()); @@ -74,9 +76,6 @@ void MetalinkParserControllerTest::testEntryTransaction() CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->languages[0]); CPPUNIT_ASSERT_EQUAL(std::string("Linux"), e->oses[0]); } - ctrl.newEntryTransaction(); - ctrl.cancelEntryTransaction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, ctrl.getResult()->getEntries().size()); } void MetalinkParserControllerTest::testResourceTransaction() @@ -90,25 +89,22 @@ void MetalinkParserControllerTest::testResourceTransaction() ctrl.setPriorityOfResource(100); ctrl.setMaxConnectionsOfResource(1); ctrl.commitEntryTransaction(); - { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().front()->resources.size()); - std::shared_ptr<MetalinkResource> res = m->getEntries().front()->resources[0]; - CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/aria2.tar.bz2"), res->url); - CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, res->type); - CPPUNIT_ASSERT_EQUAL(std::string("US"), res->location); - CPPUNIT_ASSERT_EQUAL(100, res->priority); - CPPUNIT_ASSERT_EQUAL(1, res->maxConnections); - } ctrl.newEntryTransaction(); ctrl.newResourceTransaction(); ctrl.cancelResourceTransaction(); ctrl.commitEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); + auto m = ctrl.getResult(); CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries().size()); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->resources.size()); CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[1]->resources.size()); + + auto& res = m->getEntries()[0]->resources[0]; + CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/aria2.tar.bz2"), res->url); + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, res->type); + CPPUNIT_ASSERT_EQUAL(std::string("US"), res->location); + CPPUNIT_ASSERT_EQUAL(100, res->priority); + CPPUNIT_ASSERT_EQUAL(1, res->maxConnections); } } @@ -132,22 +128,20 @@ void MetalinkParserControllerTest::testResourceTransaction_withBaseUri() #endif // ENABLE_BITTORRENT ctrl.commitEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); + auto m = ctrl.getResult(); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->resources.size()); - std::shared_ptr<MetalinkResource> res = m->getEntries()[0]->resources[0]; + auto& res = m->getEntries()[0]->resources[0]; CPPUNIT_ASSERT_EQUAL(std::string("http://base/dir/aria2.tar.bz2"), res->url); CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, res->type); #ifdef ENABLE_BITTORRENT CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries()[0]->metaurls.size()); - std::shared_ptr<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0]; CPPUNIT_ASSERT_EQUAL(std::string("http://base/meta/aria2.tar.bz2.torrent"), - metaurl->url); + m->getEntries()[0]->metaurls[0]->url); - metaurl = m->getEntries()[0]->metaurls[1]; CPPUNIT_ASSERT_EQUAL(std::string("magnet:?xt=urn:btih:248d0a1cd08284299de78d5c1ed359bb46717d8c"), - metaurl->url); + m->getEntries()[0]->metaurls[1]->url); #endif // ENABLE_BITTORRENT } } @@ -163,30 +157,26 @@ void MetalinkParserControllerTest::testMetaurlTransaction() ctrl.setNameOfMetaurl("mybirthdaycake"); ctrl.commitEntryTransaction(); #ifdef ENABLE_BITTORRENT - { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->metaurls.size()); - std::shared_ptr<MetalinkMetaurl> metaurl = m->getEntries()[0]->metaurls[0]; - CPPUNIT_ASSERT_EQUAL(std::string("http://example.org/chocolate.torrent"), - metaurl->url); - CPPUNIT_ASSERT_EQUAL(std::string("torrent"), metaurl->mediatype); - CPPUNIT_ASSERT_EQUAL(std::string("mybirthdaycake"), metaurl->name); - CPPUNIT_ASSERT_EQUAL(999, metaurl->priority); - } ctrl.newEntryTransaction(); ctrl.newMetaurlTransaction(); ctrl.cancelMetaurlTransaction(); ctrl.commitEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - CPPUNIT_ASSERT_EQUAL((size_t)2, ctrl.getResult()->getEntries().size()); + auto m = ctrl.getResult(); + CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries().size()); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries()[0]->metaurls.size()); CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[1]->metaurls.size()); + + auto& metaurl = m->getEntries()[0]->metaurls[0]; + CPPUNIT_ASSERT_EQUAL(std::string("http://example.org/chocolate.torrent"), + metaurl->url); + CPPUNIT_ASSERT_EQUAL(std::string("torrent"), metaurl->mediatype); + CPPUNIT_ASSERT_EQUAL(std::string("mybirthdaycake"), metaurl->name); + CPPUNIT_ASSERT_EQUAL(999, metaurl->priority); } #else // !ENABLE_BITTORRENT { - std::shared_ptr<Metalinker> m = ctrl.getResult(); + auto m = ctrl.getResult(); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); CPPUNIT_ASSERT_EQUAL((size_t)0, m->getEntries()[0]->metaurls.size()); } @@ -202,25 +192,28 @@ void MetalinkParserControllerTest::testChecksumTransaction() ctrl.setTypeOfChecksum("md5"); ctrl.setHashOfChecksum("acbd18db4cc2f85cedef654fccc4a4d8"); ctrl.commitEntryTransaction(); - { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - std::shared_ptr<Checksum> md = m->getEntries().front()->checksum; - CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType()); - CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"), - util::toHex(md->getDigest())); - } + ctrl.newEntryTransaction(); ctrl.newChecksumTransaction(); ctrl.setTypeOfChecksum("md5"); ctrl.setHashOfChecksum("badhash"); ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[1]->checksum); ctrl.newEntryTransaction(); ctrl.newChecksumTransaction(); ctrl.cancelChecksumTransaction(); ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[2]->checksum); + { + auto m = ctrl.getResult(); + auto& md = m->getEntries()[0]->checksum; + CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType()); + CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"), + util::toHex(md->getDigest())); + + CPPUNIT_ASSERT(!m->getEntries()[1]->checksum); + + CPPUNIT_ASSERT(!m->getEntries()[2]->checksum); + } } void MetalinkParserControllerTest::testChunkChecksumTransaction() @@ -236,9 +229,21 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction() ctrl.addHashOfChunkChecksum(2, "2cbd18db4cc2f85cedef654fccc4a4d8"); ctrl.addHashOfChunkChecksum(5, "5cbd18db4cc2f85cedef654fccc4a4d8"); ctrl.commitEntryTransaction(); + + ctrl.newEntryTransaction(); + ctrl.newChunkChecksumTransaction(); + ctrl.setTypeOfChunkChecksum("md5"); + ctrl.setLengthOfChunkChecksum(256*1024); + ctrl.addHashOfChunkChecksum(1, "badhash"); + ctrl.commitEntryTransaction(); + + ctrl.newEntryTransaction(); + ctrl.newChunkChecksumTransaction(); + ctrl.cancelChunkChecksumTransaction(); + ctrl.commitEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - std::shared_ptr<ChunkChecksum> md = m->getEntries().front()->chunkChecksum; + auto m = ctrl.getResult(); + auto& md = m->getEntries()[0]->chunkChecksum; CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType()); CPPUNIT_ASSERT_EQUAL(256*1024, md->getPieceLength()); CPPUNIT_ASSERT_EQUAL((size_t)5, md->countPieceHash()); @@ -252,20 +257,11 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction() md->getPieceHashes()[3]); CPPUNIT_ASSERT_EQUAL(std::string("5cbd18db4cc2f85cedef654fccc4a4d8"), md->getPieceHashes()[4]); - } - ctrl.newEntryTransaction(); - ctrl.newChunkChecksumTransaction(); - ctrl.setTypeOfChunkChecksum("md5"); - ctrl.setLengthOfChunkChecksum(256*1024); - ctrl.addHashOfChunkChecksum(1, "badhash"); - ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[1]->chunkChecksum); - ctrl.newEntryTransaction(); - ctrl.newChunkChecksumTransaction(); - ctrl.cancelChunkChecksumTransaction(); - ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[2]->chunkChecksum); + CPPUNIT_ASSERT(!m->getEntries()[1]->chunkChecksum); + + CPPUNIT_ASSERT(!m->getEntries()[2]->chunkChecksum); + } } void MetalinkParserControllerTest::testChunkChecksumTransactionV4() @@ -280,9 +276,22 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4() ctrl.addHashOfChunkChecksumV4("9413ee70957a09d55704123687478e07f18c7b29"); ctrl.addHashOfChunkChecksumV4("44213f9f4d59b557314fadcd233232eebcac8012"); ctrl.commitEntryTransaction(); + + ctrl.newEntryTransaction(); + ctrl.newChunkChecksumTransactionV4(); + ctrl.setTypeOfChunkChecksumV4("sha-1"); + ctrl.setLengthOfChunkChecksumV4(256*1024); + ctrl.addHashOfChunkChecksumV4("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"); + ctrl.addHashOfChunkChecksumV4("badhash"); + ctrl.commitEntryTransaction(); + + ctrl.newEntryTransaction(); + ctrl.newChunkChecksumTransactionV4(); + ctrl.cancelChunkChecksumTransactionV4(); + ctrl.commitEntryTransaction(); { - std::shared_ptr<Metalinker> m = ctrl.getResult(); - std::shared_ptr<ChunkChecksum> md = m->getEntries().front()->chunkChecksum; + auto m = ctrl.getResult(); + auto& md = m->getEntries()[0]->chunkChecksum; CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getHashType()); CPPUNIT_ASSERT_EQUAL(256*1024, md->getPieceLength()); CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash()); @@ -295,21 +304,11 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4() CPPUNIT_ASSERT_EQUAL (std::string("44213f9f4d59b557314fadcd233232eebcac8012"), util::toHex(md->getPieceHashes()[2])); - } - ctrl.newEntryTransaction(); - ctrl.newChunkChecksumTransactionV4(); - ctrl.setTypeOfChunkChecksumV4("sha-1"); - ctrl.setLengthOfChunkChecksumV4(256*1024); - ctrl.addHashOfChunkChecksumV4("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"); - ctrl.addHashOfChunkChecksumV4("badhash"); - ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[1]->chunkChecksum); - ctrl.newEntryTransaction(); - ctrl.newChunkChecksumTransactionV4(); - ctrl.cancelChunkChecksumTransactionV4(); - ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[2]->chunkChecksum); + CPPUNIT_ASSERT(!m->getEntries()[1]->chunkChecksum); + + CPPUNIT_ASSERT(!m->getEntries()[2]->chunkChecksum); + } } #endif // ENABLE_MESSAGE_DIGEST @@ -334,19 +333,20 @@ void MetalinkParserControllerTest::testSignatureTransaction() // commitEntryTransaction also commits signature transaction. ctrl.commitEntryTransaction(); - std::shared_ptr<Metalinker> m = ctrl.getResult(); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - std::shared_ptr<Signature> sig = m->getEntries().front()->getSignature(); - CPPUNIT_ASSERT_EQUAL(std::string("pgp"), sig->getType()); - CPPUNIT_ASSERT_EQUAL(std::string("aria2.sig"), sig->getFile()); - CPPUNIT_ASSERT_EQUAL(pgpSignature, sig->getBody()); - // See when signature transaction is canceled: ctrl.newEntryTransaction(); ctrl.newSignatureTransaction(); ctrl.cancelSignatureTransaction(); ctrl.commitEntryTransaction(); - CPPUNIT_ASSERT(!ctrl.getResult()->getEntries()[1]->getSignature()); + + auto m = ctrl.getResult(); + CPPUNIT_ASSERT_EQUAL((size_t)2, m->getEntries().size()); + auto& sig = m->getEntries()[0]->getSignature(); + CPPUNIT_ASSERT_EQUAL(std::string("pgp"), sig->getType()); + CPPUNIT_ASSERT_EQUAL(std::string("aria2.sig"), sig->getFile()); + CPPUNIT_ASSERT_EQUAL(pgpSignature, sig->getBody()); + + CPPUNIT_ASSERT(!m->getEntries()[1]->getSignature()); } } // namespace aria2 diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc index c74048a1..004c3767 100644 --- a/test/MetalinkProcessorTest.cc +++ b/test/MetalinkProcessorTest.cc @@ -82,12 +82,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkProcessorTest ); void MetalinkProcessorTest::testParseFileV4() { - std::shared_ptr<Metalinker> m = metalink::parseFile(A2_TEST_DIR"/metalink4.xml"); - std::shared_ptr<MetalinkEntry> e; - std::shared_ptr<MetalinkResource> r; - std::shared_ptr<MetalinkMetaurl> mu; + auto m = metalink::parseFile(A2_TEST_DIR"/metalink4.xml"); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - e = m->getEntries()[0]; + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("example.ext"), e->getPath()); CPPUNIT_ASSERT_EQUAL((int64_t)786430LL, e->getLength()); CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections); @@ -129,7 +126,7 @@ void MetalinkProcessorTest::testParseFileV4() e->getSignature()->getBody()); CPPUNIT_ASSERT_EQUAL((size_t)2, e->resources.size()); - r = e->resources[0]; + auto& r = e->resources[0]; CPPUNIT_ASSERT_EQUAL(std::string("ftp://ftp.example.com/example.ext"), r->url); CPPUNIT_ASSERT_EQUAL(std::string("de"), r->location); @@ -139,7 +136,7 @@ void MetalinkProcessorTest::testParseFileV4() CPPUNIT_ASSERT_EQUAL(-1, r->maxConnections); #ifdef ENABLE_BITTORRENT CPPUNIT_ASSERT_EQUAL((size_t)1, e->metaurls.size()); - mu = e->metaurls[0]; + auto& mu = e->metaurls[0]; CPPUNIT_ASSERT_EQUAL(std::string("http://example.com/example.ext.torrent"), mu->url); CPPUNIT_ASSERT_EQUAL(2, mu->priority); @@ -151,7 +148,7 @@ void MetalinkProcessorTest::testParseFileV4() void MetalinkProcessorTest::testParseFileV4_attrs() { - std::shared_ptr<Metalinker> m; + std::unique_ptr<Metalinker> m; ByteArrayDiskWriter dw; { // Testing file@name @@ -492,13 +489,10 @@ void MetalinkProcessorTest::testParseFileV4_attrs() void MetalinkProcessorTest::testParseFile() { try { - std::shared_ptr<Metalinker> metalinker = - metalink::parseFile(A2_TEST_DIR"/test.xml"); + auto metalinker = metalink::parseFile(A2_TEST_DIR"/test.xml"); + auto entryItr = std::begin(metalinker->getEntries()); - std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr = - metalinker->getEntries().begin(); - - std::shared_ptr<MetalinkEntry> entry1 = *entryItr; + auto& entry1 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath()); CPPUNIT_ASSERT_EQUAL((int64_t)0LL, entry1->getLength()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version); @@ -527,9 +521,8 @@ void MetalinkProcessorTest::testParseFile() "\t"), entry1->getSignature()->getBody()); - std::vector<std::shared_ptr<MetalinkResource> >::iterator resourceItr1 = - entry1->resources.begin(); - std::shared_ptr<MetalinkResource> resource1 = *resourceItr1; + auto resourceItr1 = std::begin(entry1->resources); + auto& resource1 = *resourceItr1; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, resource1->type); CPPUNIT_ASSERT_EQUAL(std::string("jp"), resource1->location); CPPUNIT_ASSERT_EQUAL(1, resource1->priority); @@ -537,8 +530,8 @@ void MetalinkProcessorTest::testParseFile() resource1->url); CPPUNIT_ASSERT_EQUAL(1, resource1->maxConnections); - resourceItr1++; - std::shared_ptr<MetalinkResource> resource2 = *resourceItr1; + ++resourceItr1; + auto& resource2 = *resourceItr1; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, resource2->type); CPPUNIT_ASSERT_EQUAL(std::string("us"), resource2->location); CPPUNIT_ASSERT_EQUAL(1, resource2->priority); @@ -546,9 +539,9 @@ void MetalinkProcessorTest::testParseFile() resource2->url); CPPUNIT_ASSERT_EQUAL(-1, resource2->maxConnections); - entryItr++; + ++entryItr; - std::shared_ptr<MetalinkEntry> entry2 = *entryItr; + auto& entry2 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath()); CPPUNIT_ASSERT_EQUAL((int64_t)345689LL, entry2->getLength()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version); @@ -569,20 +562,20 @@ void MetalinkProcessorTest::testParseFile() // See that signature is null CPPUNIT_ASSERT(!entry2->getSignature()); - entryItr++; + ++entryItr; // test case: verification hash is not provided - std::shared_ptr<MetalinkEntry> entry3 = *entryItr; + auto& entry3 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("NoVerificationHash"), entry3->getPath()); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT(!entry3->checksum); CPPUNIT_ASSERT(!entry3->chunkChecksum); #endif // ENABLE_MESSAGE_DIGEST - entryItr++; + ++entryItr; // test case: unsupported verification hash is included - std::shared_ptr<MetalinkEntry> entry4 = *entryItr; + auto& entry4 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath()); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType()); @@ -599,10 +592,10 @@ void MetalinkProcessorTest::testParseFile() void MetalinkProcessorTest::testParseFile_dirtraversal() { - std::shared_ptr<Metalinker> metalinker = + auto metalinker = metalink::parseFile(A2_TEST_DIR"/metalink3-dirtraversal.xml"); CPPUNIT_ASSERT_EQUAL((size_t)1, metalinker->getEntries().size()); - std::shared_ptr<MetalinkEntry> e = metalinker->getEntries()[0]; + auto& e = metalinker->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.3.tar.bz2"), e->getPath()); CPPUNIT_ASSERT(e->getSignature()); CPPUNIT_ASSERT_EQUAL(std::string(""), e->getSignature()->getFile()); @@ -615,11 +608,8 @@ void MetalinkProcessorTest::testParseBinaryStream() dw.openExistingFile(); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - - std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr = - m->getEntries().begin(); - std::shared_ptr<MetalinkEntry> entry1 = *entryItr; + auto m = metalink::parseBinaryStream(&dw); + auto& entry1 = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); @@ -632,7 +622,7 @@ void MetalinkProcessorTest::testMalformedXML() dw.setString("<metalink version=\"3.0\" xmlns=\"http://www.metalinker.org/\"><files></file></metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); + metalink::parseBinaryStream(&dw); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { std::cerr << e.stackTrace() << std::endl; @@ -645,7 +635,7 @@ void MetalinkProcessorTest::testMalformedXML2() dw.setString("<metalink version=\"3.0\" xmlns=\"http://www.metalinker.org/\"><files></files>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); + metalink::parseBinaryStream(&dw); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { std::cerr << e.stackTrace() << std::endl; @@ -654,7 +644,6 @@ void MetalinkProcessorTest::testMalformedXML2() void MetalinkProcessorTest::testBadSizeV4() { - std::shared_ptr<Metalinker> m; ByteArrayDiskWriter dw; const char* tmpl = @@ -667,11 +656,11 @@ void MetalinkProcessorTest::testBadSizeV4() "</metalink>"; dw.setString(fmt(tmpl, "9223372036854775807")); - m = metalink::parseBinaryStream(&dw); + metalink::parseBinaryStream(&dw); dw.setString(fmt(tmpl, "-1")); try { - m = metalink::parseBinaryStream(&dw); + metalink::parseBinaryStream(&dw); CPPUNIT_FAIL("exception must be thrown."); } catch(RecoverableException& e) {} } @@ -691,17 +680,13 @@ void MetalinkProcessorTest::testBadSize() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - - std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr = - m->getEntries().begin(); - std::shared_ptr<MetalinkEntry> e = *entryItr; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath()); CPPUNIT_ASSERT_EQUAL((int64_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]); - } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); } @@ -723,11 +708,8 @@ void MetalinkProcessorTest::testBadMaxConn() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - - std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr = - m->getEntries().begin(); - std::shared_ptr<MetalinkEntry> e = *entryItr; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL((int64_t)43743838LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); @@ -755,11 +737,9 @@ void MetalinkProcessorTest::testNoName() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); + auto m = metalink::parseBinaryStream(&dw); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator entryItr = - m->getEntries().begin(); - std::shared_ptr<MetalinkEntry> e = *entryItr; + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); @@ -785,9 +765,9 @@ void MetalinkProcessorTest::testBadURLPrefs() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<MetalinkResource> r = e->resources[0]; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; + auto& r = e->resources[0]; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type); CPPUNIT_ASSERT_EQUAL(MetalinkResource::getLowestPriority(), r->priority); CPPUNIT_ASSERT_EQUAL(1, r->maxConnections); @@ -817,9 +797,9 @@ void MetalinkProcessorTest::testBadURLMaxConn() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<MetalinkResource> r = e->resources[0]; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; + auto& r = e->resources[0]; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type); CPPUNIT_ASSERT_EQUAL(1, r->priority); CPPUNIT_ASSERT_EQUAL(-1, r->maxConnections); @@ -850,14 +830,14 @@ void MetalinkProcessorTest::testUnsupportedType() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL((size_t)3, e->resources.size()); - std::shared_ptr<MetalinkResource> r1 = e->resources[0]; + auto& r1 = e->resources[0]; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r1->type); - std::shared_ptr<MetalinkResource> r2 = e->resources[1]; + auto& r2 = e->resources[1]; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_NOT_SUPPORTED, r2->type); - std::shared_ptr<MetalinkResource> r3 = e->resources[2]; + auto& r3 = e->resources[2]; CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, r3->type); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); @@ -882,10 +862,9 @@ void MetalinkProcessorTest::testMultiplePieces() try { // aria2 prefers sha1 - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<ChunkChecksum> c = e->chunkChecksum; - + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; + auto& c = e->chunkChecksum; CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType()); CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength()); } catch(Exception& e) { @@ -914,10 +893,9 @@ void MetalinkProcessorTest::testBadPieceNo() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<ChunkChecksum> c = e->chunkChecksum; - + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; + auto& c = e->chunkChecksum; CPPUNIT_ASSERT(c); CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType()); @@ -946,10 +924,10 @@ void MetalinkProcessorTest::testBadPieceLength() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); + auto m = metalink::parseBinaryStream(&dw); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<ChunkChecksum> c = e->chunkChecksum; + auto& e = m->getEntries()[0]; + auto& c = e->chunkChecksum; CPPUNIT_ASSERT(c); CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType()); @@ -978,10 +956,9 @@ void MetalinkProcessorTest::testUnsupportedType_piece() "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; - std::shared_ptr<ChunkChecksum> c = e->chunkChecksum; - + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; + auto& c = e->chunkChecksum; CPPUNIT_ASSERT(c); CPPUNIT_ASSERT_EQUAL(1024, c->getPieceLength()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType()); @@ -1006,8 +983,8 @@ void MetalinkProcessorTest::testLargeFileSize() "</files>" "</metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; + auto m = metalink::parseBinaryStream(&dw); + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); @@ -1029,9 +1006,9 @@ void MetalinkProcessorTest::testXmlPrefixV3() "</m:metalink>"); try { - std::shared_ptr<Metalinker> m = metalink::parseBinaryStream(&dw); + auto m = metalink::parseBinaryStream(&dw); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); - std::shared_ptr<MetalinkEntry> e = m->getEntries()[0]; + auto& e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); diff --git a/test/MetalinkerTest.cc b/test/MetalinkerTest.cc index e0584846..fc6e5363 100644 --- a/test/MetalinkerTest.cc +++ b/test/MetalinkerTest.cc @@ -3,6 +3,7 @@ #include <cppunit/extensions/HelperMacros.h> #include "MetalinkEntry.h" +#include "a2functional.h" namespace aria2 { @@ -25,18 +26,19 @@ public: CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkerTest ); -void MetalinkerTest::testQueryEntry() { - std::shared_ptr<Metalinker> metalinker(new Metalinker()); - std::shared_ptr<MetalinkEntry> entry1(new MetalinkEntry()); +void MetalinkerTest::testQueryEntry() +{ + Metalinker metalinker; + auto entry1 = make_unique<MetalinkEntry>(); entry1->version = "0.5.2"; entry1->languages.push_back("en-US"); entry1->oses.push_back("Linux-x86"); - std::shared_ptr<MetalinkEntry> entry2(new MetalinkEntry()); + auto entry2 = make_unique<MetalinkEntry>(); entry2->version = "0.5.1"; entry2->languages.push_back("ja-JP"); entry2->oses.push_back("Linux-m68k"); - metalinker->addEntry(entry1); - metalinker->addEntry(entry2); + metalinker.addEntry(std::move(entry1)); + metalinker.addEntry(std::move(entry2)); std::string version; std::string language; @@ -46,8 +48,7 @@ void MetalinkerTest::testQueryEntry() { language = "ja-JP"; os = "Linux-m68k"; { - std::vector<std::shared_ptr<MetalinkEntry> > result; - metalinker->queryEntry(result, version, language, os); + auto result = metalinker.queryEntry(version, language, os); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), result.at(0)->version); CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), result.at(0)->languages[0]); @@ -57,8 +58,7 @@ void MetalinkerTest::testQueryEntry() { language = ""; os = ""; { - std::vector<std::shared_ptr<MetalinkEntry> > result; - metalinker->queryEntry(result, version, language, os); + auto result = metalinker.queryEntry(version, language, os); CPPUNIT_ASSERT_EQUAL((size_t)0, result.size()); } @@ -66,8 +66,7 @@ void MetalinkerTest::testQueryEntry() { language = ""; os = ""; { - std::vector<std::shared_ptr<MetalinkEntry> > result; - metalinker->queryEntry(result, version, language, os); + auto result = metalinker.queryEntry(version, language, os); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), result.at(0)->version); CPPUNIT_ASSERT_EQUAL(std::string("en-US"), result.at(0)->languages[0]); |