Use std::unique_ptr for Metalink objects

5 files changed, 203 insertions, 234 deletions

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]);