Wrap BtMessage objects by std::unique_ptr instead of std::shared_ptr

15 files changed, 361 insertions, 415 deletions

diff --git a/test/BtCancelMessageTest.cc b/test/BtCancelMessageTest.cc
index e6dd3443..20420f53 100644
--- a/test/BtCancelMessageTest.cc
+++ b/test/BtCancelMessageTest.cc
@@ -41,7 +41,7 @@ public:
                                length(0) {}
 
     virtual void doCancelSendingPieceAction
-    (size_t index, int32_t begin, int32_t length) {
+    (size_t index, int32_t begin, int32_t length) override {
       this->index = index;
       this->begin = begin;
       this->length = length;
@@ -58,7 +58,7 @@ void BtCancelMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  std::shared_ptr<BtCancelMessage> pm(BtCancelMessage::create(&msg[4], 13));
+  auto pm = BtCancelMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((uint8_t)8, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -103,8 +103,7 @@ void BtCancelMessageTest::testDoReceivedAction() {
   msg.setBegin(2*16*1024);
   msg.setLength(16*1024);
   msg.setPeer(peer);
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
-    (new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
 
   msg.doReceivedAction();
diff --git a/test/BtChokeMessageTest.cc b/test/BtChokeMessageTest.cc
index 35dd6fa9..1fefcf35 100644
--- a/test/BtChokeMessageTest.cc
+++ b/test/BtChokeMessageTest.cc
@@ -43,13 +43,18 @@ public:
     bool doChokedActionCalled;
     bool doChokingActionCalled;
   public:
-    MockBtMessageDispatcher2():doChokedActionCalled(false), doChokingActionCalled(false) {}
+    MockBtMessageDispatcher2()
+      : doChokedActionCalled{false},
+        doChokingActionCalled{false}
+    {}
 
-    virtual void doChokedAction() {
+    virtual void doChokedAction() override
+    {
       doChokedActionCalled = true;
     }
 
-    virtual void doChokingAction() {
+    virtual void doChokingAction() override
+    {
       doChokingActionCalled = true;
     }
   };
@@ -58,9 +63,10 @@ public:
   public:
     bool doChokedActionCalled;
   public:
-    MockBtRequestFactory2():doChokedActionCalled(false) {}
+    MockBtRequestFactory2():doChokedActionCalled{false} {}
 
-    virtual void doChokedAction() {
+    virtual void doChokedAction() override
+    {
       doChokedActionCalled = true;
     }
   };
@@ -72,7 +78,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtChokeMessageTest);
 void BtChokeMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 0);
-  std::shared_ptr<BtChokeMessage> pm(BtChokeMessage::create(&msg[4], 1));
+  auto pm = BtChokeMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((uint8_t)0, pm->getId());
 
   // case: payload size is wrong
@@ -106,9 +112,9 @@ void BtChokeMessageTest::testDoReceivedAction() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
-  std::shared_ptr<MockBtRequestFactory2> requestFactory(new MockBtRequestFactory2());
+  auto requestFactory = make_unique<MockBtRequestFactory2>();
   msg.setBtRequestFactory(requestFactory.get());
 
   msg.doReceivedAction();
@@ -121,10 +127,10 @@ void BtChokeMessageTest::testOnSendComplete() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
 
-  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
+  auto pu = std::unique_ptr<ProgressUpdate>{msg.getProgressUpdate()};
   pu->update(0, true);
 
   CPPUNIT_ASSERT(dispatcher->doChokingActionCalled);
diff --git a/test/BtPieceMessageTest.cc b/test/BtPieceMessageTest.cc
index d758d53c..285ba21f 100644
--- a/test/BtPieceMessageTest.cc
+++ b/test/BtPieceMessageTest.cc
@@ -15,6 +15,7 @@
 #include "Piece.h"
 #include "BtHandshakeMessage.h"
 #include "DownloadContext.h"
+#include "BtRejectMessage.h"
 
 namespace aria2 {
 
@@ -47,44 +48,33 @@ public:
   void testCancelSendingPieceEvent_invalidate();
   void testToString();
 
-  class MockBtMessage2 : public MockBtMessage {
-  public:
-    size_t index;
-    uint32_t begin;
-    size_t length;
-  public:
-    MockBtMessage2(size_t index, uint32_t begin, size_t length):index(index), begin(begin), length(length) {}
-
-  };
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
+    virtual std::unique_ptr<BtRejectMessage>
     createRejectMessage(size_t index,
                         int32_t begin,
                         int32_t length) {
-      std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2(index, begin, length));
-      return msg;
+      return make_unique<BtRejectMessage>(index, begin, length);
     }
   };
 
-  std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<MockBtMessageDispatcher> btMessageDispatcher;
-  std::shared_ptr<MockBtMessageFactory> btMessageFactory_;
+  std::unique_ptr<DownloadContext> dctx_;
+  std::unique_ptr<MockBtMessageDispatcher> btMessageDispatcher;
+  std::unique_ptr<MockBtMessageFactory> btMessageFactory_;
   std::shared_ptr<Peer> peer;
-  std::shared_ptr<BtPieceMessage> msg;
+  std::unique_ptr<BtPieceMessage> msg;
 
   void setUp() {
-    dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file"));
+    dctx_ = make_unique<DownloadContext>(16*1024, 256*1024, "/path/to/file");
 
-    peer.reset(new Peer("host", 6969));
+    peer = std::make_shared<Peer>("host", 6969);
     peer->allocateSessionResource(dctx_->getPieceLength(),
                                   dctx_->getTotalLength());
 
-    btMessageDispatcher.reset(new MockBtMessageDispatcher());
-    btMessageFactory_.reset(new MockBtMessageFactory2());
+    btMessageDispatcher = make_unique<MockBtMessageDispatcher>();
+    btMessageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    msg.reset(new BtPieceMessage());
+    msg = make_unique<BtPieceMessage>();
     msg->setIndex(1);
     msg->setBegin(1024);
     msg->setBlockLength(16*1024);
@@ -166,11 +156,11 @@ void BtPieceMessageTest::testChokingEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
-    (btMessageDispatcher->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
+  auto rej = static_cast<const BtRejectMessage*>
+    (btMessageDispatcher->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
 }
 
 void BtPieceMessageTest::testChokingEvent_inAmAllowedIndexSet() {
@@ -234,11 +224,11 @@ void BtPieceMessageTest::testCancelSendingPieceEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
-    (btMessageDispatcher->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
+  auto rej = static_cast<const BtRejectMessage*>
+    (btMessageDispatcher->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
 }
 
 void BtPieceMessageTest::testCancelSendingPieceEvent_invalidate() {
diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc
index 808c3068..32cbe3a0 100644
--- a/test/BtRequestMessageTest.cc
+++ b/test/BtRequestMessageTest.cc
@@ -54,62 +54,44 @@ public:
 
   class MockPieceStorage2 : public MockPieceStorage {
   public:
-    virtual bool hasPiece(size_t index) {
+    virtual bool hasPiece(size_t index) override
+    {
       return index == 1;
     }
   };
 
-  class MockBtMessage2 : public MockBtMessage {
-  public:
-    std::string type;
-    size_t index;
-    uint32_t begin;
-    size_t length;
-  public:
-    MockBtMessage2(std::string type, size_t index, uint32_t begin,
-                   size_t length)
-      :
-      type(type), index(index), begin(begin), length(length) {}
-  };
-
-  typedef std::shared_ptr<MockBtMessage2> MockBtMessage2Handle;
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createPieceMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg
-        (new MockBtMessage2("piece", index, begin, length));
-      return btMsg;
+    virtual std::unique_ptr<BtPieceMessage>
+    createPieceMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtPieceMessage>(index, begin, length);
     }
 
-    virtual std::shared_ptr<BtMessage>
-    createRejectMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg
-        (new MockBtMessage2("reject", index, begin, length));
-      return btMsg;
+    virtual std::unique_ptr<BtRejectMessage>
+    createRejectMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtRejectMessage>(index, begin, length);
     }
   };
 
-  typedef std::shared_ptr<MockBtMessageFactory2> MockBtMessageFactory2Handle;
-
-  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::unique_ptr<MockPieceStorage> pieceStorage_;
   std::shared_ptr<Peer> peer_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<BtRequestMessage> msg;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<BtRequestMessage> msg;
 
   void setUp() {
-    pieceStorage_.reset(new MockPieceStorage2());
+    pieceStorage_ = make_unique<MockPieceStorage2>();
 
-    peer_.reset(new Peer("host", 6969));
+    peer_ = std::make_shared<Peer>("host", 6969);
     peer_->allocateSessionResource(16*1024, 256*1024);
 
-    dispatcher_.reset(new MockBtMessageDispatcher());
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
 
-    messageFactory_.reset(new MockBtMessageFactory2());
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    msg.reset(new BtRequestMessage());
+    msg = make_unique<BtRequestMessage>();
     msg->setPeer(peer_);
     msg->setIndex(1);
     msg->setBegin(16);
@@ -130,7 +112,7 @@ void BtRequestMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  std::shared_ptr<BtRequestMessage> pm(BtRequestMessage::create(&msg[4], 13));
+  auto pm = BtRequestMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((uint8_t)6, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -174,12 +156,13 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() {
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("piece"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtPieceMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto pieceMsg = static_cast<const BtPieceMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, pieceMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, pieceMsg->getBlockLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionEnabled() {
@@ -188,12 +171,13 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExten
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtRejectMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto rejectMsg = static_cast<const BtRejectMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rejectMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, rejectMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, rejectMsg->getLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionDisabled() {
@@ -210,12 +194,13 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionE
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtRejectMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto rejectMsg = static_cast<const BtRejectMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, rejectMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, rejectMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, rejectMsg->getLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionDisabled() {
@@ -227,21 +212,21 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionD
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent() {
-  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
+  auto piece = std::make_shared<Piece>(1, 16*1024);
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() {
-  std::shared_ptr<Piece> piece(new Piece(2, 16*1024));
+  auto piece = std::make_shared<Piece>(2, 16*1024);
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(!msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() {
-  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
+  auto piece = std::make_shared<Piece>(1, 16*1024);
   msg->setInvalidate(true);
   CPPUNIT_ASSERT(msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
diff --git a/test/BtSuggestPieceMessageTest.cc b/test/BtSuggestPieceMessageTest.cc
index 4abf051a..c680bc94 100644
--- a/test/BtSuggestPieceMessageTest.cc
+++ b/test/BtSuggestPieceMessageTest.cc
@@ -32,9 +32,8 @@ void BtSuggestPieceMessageTest::testCreate() {
   unsigned char msg[9];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 5, 13);
   bittorrent::setIntParam(&msg[5], 12345);
-  std::shared_ptr<BtSuggestPieceMessage> pm
-    (BtSuggestPieceMessage::create(&msg[4], 5));
-  CPPUNIT_ASSERT_EQUAL((uint8_t)13, pm->getId());
+  auto pm = BtSuggestPieceMessage::create(&msg[4], 5);
+  CPPUNIT_ASSERT(BtSuggestPieceMessage::ID == pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
 
   // case: payload size is wrong
diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc
index 0100df75..4b718685 100644
--- a/test/DefaultBtMessageDispatcherTest.cc
+++ b/test/DefaultBtMessageDispatcherTest.cc
@@ -43,13 +43,13 @@ class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture {
 private:
   std::shared_ptr<DownloadContext> dctx_;
   std::shared_ptr<Peer> peer;
-  std::shared_ptr<DefaultBtMessageDispatcher> btMessageDispatcher;
-  std::shared_ptr<MockPeerStorage> peerStorage;
-  std::shared_ptr<MockPieceStorage> pieceStorage;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<RequestGroupMan> rgman_;
+  std::unique_ptr<DefaultBtMessageDispatcher> btMessageDispatcher;
+  std::unique_ptr<MockPeerStorage> peerStorage;
+  std::unique_ptr<MockPieceStorage> pieceStorage;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<RequestGroupMan> rgman_;
   std::shared_ptr<Option> option_;
-  std::shared_ptr<RequestGroup> rg_;
+  std::unique_ptr<RequestGroup> rg_;
 public:
   void tearDown() {}
 
@@ -66,45 +66,43 @@ public:
   void testGetOutstandingRequest();
   void testRemoveOutstandingRequest();
 
-  class MockBtMessage2 : public MockBtMessage {
-  private:
+  struct EventCheck {
+    EventCheck() : onQueuedCalled{false}, sendCalled{false},
+      doCancelActionCalled{false}
+    {}
     bool onQueuedCalled;
     bool sendCalled;
     bool doCancelActionCalled;
+  };
+
+  class MockBtMessage2 : public MockBtMessage {
   public:
+    EventCheck* evcheck;
     std::string type;
-  public:
-    MockBtMessage2():onQueuedCalled(false),
-                     sendCalled(false),
-                     doCancelActionCalled(false)
+    MockBtMessage2(EventCheck* evcheck = nullptr)
+      : evcheck{evcheck}
     {}
 
-    virtual ~MockBtMessage2() {}
-
-    virtual void onQueued() {
-      onQueuedCalled = true;
-    }
-
-    bool isOnQueuedCalled() const {
-      return onQueuedCalled;
-    }
-
-    virtual void send() {
-      sendCalled = true;
+    virtual void onQueued() override
+    {
+      if(evcheck){
+        evcheck->onQueuedCalled = true;
+      }
     }
 
-    bool isSendCalled() const {
-      return sendCalled;
+    virtual void send() override
+    {
+      if(evcheck) {
+        evcheck->sendCalled = true;
+      }
     }
 
     virtual void onCancelSendingPieceEvent
-    (const BtCancelSendingPieceEvent& event)
+    (const BtCancelSendingPieceEvent& event) override
     {
-      doCancelActionCalled = true;
-    }
-
-    bool isDoCancelActionCalled() const {
-      return doCancelActionCalled;
+      if(evcheck) {
+        evcheck->doCancelActionCalled = true;
+      }
     }
   };
 
@@ -112,48 +110,50 @@ public:
   private:
     std::shared_ptr<Piece> piece;
   public:
-    virtual std::shared_ptr<Piece> getPiece(size_t index) {
+    virtual std::shared_ptr<Piece> getPiece(size_t index) override
+    {
       return piece;
     }
 
-    void setPiece(const std::shared_ptr<Piece>& piece) {
+    void setPiece(const std::shared_ptr<Piece>& piece)
+    {
       this->piece = piece;
     }
   };
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createCancelMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg(new MockBtMessage2());
-      btMsg->type = "cancel";
-      return btMsg;
+    virtual std::unique_ptr<BtCancelMessage>
+    createCancelMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtCancelMessage>(index, begin, length);
     }
   };
 
-  void setUp() {
-    option_.reset(new Option());
+  void setUp()
+  {
+    option_ = std::make_shared<Option>();
     option_->put(PREF_DIR, ".");
 
-    rg_.reset(new RequestGroup(GroupId::create(), option_));
+    rg_ = make_unique<RequestGroup>(GroupId::create(), option_);
 
-    dctx_.reset(new DownloadContext());
+    dctx_ = std::make_shared<DownloadContext>();
     bittorrent::load(A2_TEST_DIR"/test.torrent", dctx_, option_);
 
     rg_->setDownloadContext(dctx_);
 
-    peer.reset(new Peer("192.168.0.1", 6969));
+    peer = std::make_shared<Peer>("192.168.0.1", 6969);
     peer->allocateSessionResource
       (dctx_->getPieceLength(), dctx_->getTotalLength());
-    peerStorage.reset(new MockPeerStorage());
-    pieceStorage.reset(new MockPieceStorage());
+    peerStorage = make_unique<MockPeerStorage>();
+    pieceStorage = make_unique<MockPieceStorage>();
 
-    messageFactory_.reset(new MockBtMessageFactory2());
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    rgman_.reset(new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(),
-                                     0, option_.get()));
+    rgman_ = make_unique<RequestGroupMan>
+      (std::vector<std::shared_ptr<RequestGroup>>{}, 0, option_.get());
 
-    btMessageDispatcher.reset(new DefaultBtMessageDispatcher());
+    btMessageDispatcher = make_unique<DefaultBtMessageDispatcher>();
     btMessageDispatcher->setPeer(peer);
     btMessageDispatcher->setDownloadContext(dctx_.get());
     btMessageDispatcher->setPieceStorage(pieceStorage.get());
@@ -167,87 +167,66 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtMessageDispatcherTest);
 
-void DefaultBtMessageDispatcherTest::testAddMessage() {
-  std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2());
-  CPPUNIT_ASSERT_EQUAL(false, msg->isOnQueuedCalled());
-  btMessageDispatcher->addMessageToQueue(msg);
-  CPPUNIT_ASSERT_EQUAL(true, msg->isOnQueuedCalled());
+void DefaultBtMessageDispatcherTest::testAddMessage()
+  {
+  auto evcheck = EventCheck{};
+  auto msg = make_unique<MockBtMessage2>(&evcheck);
+  btMessageDispatcher->addMessageToQueue(std::move(msg));
+  CPPUNIT_ASSERT_EQUAL(true, evcheck.onQueuedCalled);
   CPPUNIT_ASSERT_EQUAL((size_t)1,
                        btMessageDispatcher->getMessageQueue().size());
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
   msg1->setUploading(false);
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
   msg2->setUploading(false);
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
   btMessageDispatcher->sendMessagesInternal();
 
-  CPPUNIT_ASSERT(msg1->isSendCalled());
-  CPPUNIT_ASSERT(msg2->isSendCalled());
+  CPPUNIT_ASSERT(evcheck1.sendCalled);
+  CPPUNIT_ASSERT(evcheck2.sendCalled);
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
   msg1->setUploading(true);
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
   msg2->setUploading(true);
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
   btMessageDispatcher->sendMessagesInternal();
 
-  CPPUNIT_ASSERT(msg1->isSendCalled());
-  CPPUNIT_ASSERT(msg2->isSendCalled());
+  CPPUNIT_ASSERT(evcheck1.sendCalled);
+  CPPUNIT_ASSERT(evcheck2.sendCalled);
 }
 
-// TODO Because we no longer directly use PeerStorage::calculateStat()
-// and Neither RequestGroup nor RequestGroupMan can be stubbed, this
-// test is commented out for now.
-//
-// void DefaultBtMessageDispatcherTest::testSendMessages_overUploadLimit() {
-//   btMessageDispatcher->setMaxUploadSpeedLimit(100);
-//   TransferStat stat;
-//   stat.setUploadSpeed(150);
-//   peerStorage->setStat(stat);
-
-//   std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
-//   msg1->setUploading(true);
-//   std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
-//   msg2->setUploading(true);
-//   std::shared_ptr<MockBtMessage2> msg3(new MockBtMessage2());
-//   msg3->setUploading(false);
-
-//   btMessageDispatcher->addMessageToQueue(msg1);
-//   btMessageDispatcher->addMessageToQueue(msg2);
-//   btMessageDispatcher->addMessageToQueue(msg3);
-//   btMessageDispatcher->sendMessagesInternal();
-
-//   CPPUNIT_ASSERT(!msg1->isSendCalled());
-//   CPPUNIT_ASSERT(!msg2->isSendCalled());
-//   CPPUNIT_ASSERT(msg3->isSendCalled());
-
-//   CPPUNIT_ASSERT_EQUAL((size_t)2,
-//                     btMessageDispatcher->getMessageQueue().size());
-// }
-
-void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
-
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction()
+{
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
+
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
 
   btMessageDispatcher->doCancelSendingPieceAction(0, 0, 0);
 
-  CPPUNIT_ASSERT_EQUAL(true, msg1->isDoCancelActionCalled());
-  CPPUNIT_ASSERT_EQUAL(true, msg2->isDoCancelActionCalled());
+  CPPUNIT_ASSERT(evcheck1.doCancelActionCalled);
+  CPPUNIT_ASSERT(evcheck2.doCancelActionCalled);
 }
 
 int MY_PIECE_LENGTH = 16*1024;
 
-void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
+void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing()
+{
   auto piece = std::make_shared<Piece>(0, MY_PIECE_LENGTH);
   size_t index;
   CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
diff --git a/test/DefaultBtMessageFactoryTest.cc b/test/DefaultBtMessageFactoryTest.cc
index cf4c6954..048744f0 100644
--- a/test/DefaultBtMessageFactoryTest.cc
+++ b/test/DefaultBtMessageFactoryTest.cc
@@ -24,22 +24,22 @@ class DefaultBtMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreatePortMessage);
   CPPUNIT_TEST_SUITE_END();
 private:
-  std::shared_ptr<DownloadContext> dctx_;
+  std::unique_ptr<DownloadContext> dctx_;
   std::shared_ptr<Peer> peer_;
   std::shared_ptr<MockExtensionMessageFactory> exmsgFactory_;
-  std::shared_ptr<DefaultBtMessageFactory> factory_;
+  std::unique_ptr<DefaultBtMessageFactory> factory_;
 public:
   void setUp()
   {
-    dctx_.reset(new DownloadContext());
+    dctx_ = make_unique<DownloadContext>();
 
-    peer_.reset(new Peer("192.168.0.1", 6969));
+    peer_ = std::make_shared<Peer>("192.168.0.1", 6969);
     peer_->allocateSessionResource(1024, 1024*1024);
     peer_->setExtendedMessagingEnabled(true);
 
-    exmsgFactory_.reset(new MockExtensionMessageFactory());
+    exmsgFactory_ = std::make_shared<MockExtensionMessageFactory>();
 
-    factory_.reset(new DefaultBtMessageFactory());
+    factory_ = make_unique<DefaultBtMessageFactory>();
     factory_->setDownloadContext(dctx_.get());
     factory_->setPeer(peer_);
     factory_->setExtensionMessageFactory(exmsgFactory_);
@@ -62,9 +62,9 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage()
   msg[5] = 1; // Set dummy extended message ID 1
   memcpy(msg+6, payload.c_str(), payload.size());
 
-  auto m = std::dynamic_pointer_cast<BtExtendedMessage>
-    (factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg)));
-
+  auto m =
+    factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg));
+  CPPUNIT_ASSERT(BtExtendedMessage::ID == m->getId());
   try {
     // disable extended messaging
     peer_->setExtendedMessagingEnabled(false);
@@ -82,17 +82,16 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
     bittorrent::createPeerMessageString(data, sizeof(data), 3, 9);
     bittorrent::setShortIntParam(&data[5], 6881);
     try {
-      auto m = std::dynamic_pointer_cast<BtPortMessage>
-        (factory_->createBtMessage(&data[4], sizeof(data)-4));
-      CPPUNIT_ASSERT(m);
+      auto r = factory_->createBtMessage(&data[4], sizeof(data)-4);
+      CPPUNIT_ASSERT(BtPortMessage::ID == r->getId());
+      auto m = static_cast<const BtPortMessage*>(r.get());
       CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
     } catch(Exception& e) {
       CPPUNIT_FAIL(e.stackTrace());
     }
   }
   {
-    auto m = std::dynamic_pointer_cast<BtPortMessage>
-      (factory_->createPortMessage(6881));
+    auto m = factory_->createPortMessage(6881);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
   }
 }
diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc
index cfc4e4b3..cc7d724d 100644
--- a/test/DefaultBtRequestFactoryTest.cc
+++ b/test/DefaultBtRequestFactoryTest.cc
@@ -28,11 +28,10 @@ class DefaultBtRequestFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 private:
   std::shared_ptr<Peer> peer_;
-  std::shared_ptr<DefaultBtRequestFactory> requestFactory_;
-  std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<MockPieceStorage> pieceStorage_;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<DefaultBtRequestFactory> requestFactory_;
+  std::unique_ptr<MockPieceStorage> pieceStorage_;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
 public:
   void testAddTargetPiece();
   void testRemoveCompletedPiece();
@@ -50,53 +49,43 @@ public:
       index(index), blockIndex(blockIndex) {}
   };
 
-  typedef std::shared_ptr<MockBtRequestMessage> MockBtRequestMessageHandle;
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
-      return std::shared_ptr<BtMessage>
-        (new MockBtRequestMessage(piece->getIndex(), blockIndex));
+    virtual std::unique_ptr<BtRequestMessage>
+    createRequestMessage(const std::shared_ptr<Piece>& piece,
+                         size_t blockIndex) override
+    {
+      return make_unique<BtRequestMessage>(piece->getIndex(), 0, 0,
+                                           blockIndex);
     }
   };
 
   class MockBtMessageDispatcher2 : public MockBtMessageDispatcher {
   public:
-    virtual bool isOutstandingRequest(size_t index, size_t blockIndex) {
+    virtual bool isOutstandingRequest(size_t index, size_t blockIndex) override
+    {
       return index == 0 && blockIndex == 0;
     }
   };
 
-  class SortMockBtRequestMessage {
+  class BtRequestMessageSorter {
   public:
-    bool operator()(const std::shared_ptr<MockBtRequestMessage>& a,
-                    const std::shared_ptr<MockBtRequestMessage>& b) {
-      if(a->index < b->index) {
-        return true;
-      } else if(b->index < a->index) {
-        return false;
-      } else if(a->blockIndex < b->blockIndex) {
-        return true;
-      } else if(b->blockIndex < a->blockIndex) {
-        return false;
-      } else {
-        return true;
-      }
+    bool operator()(const std::unique_ptr<BtRequestMessage>& a,
+                    const std::unique_ptr<BtRequestMessage>& b)
+    {
+      return a->getIndex() < b->getIndex() ||
+        (a->getIndex() == b->getIndex() &&
+         a->getBlockIndex() < b->getBlockIndex());
     }
   };
 
   void setUp()
   {
-    pieceStorage_.reset(new MockPieceStorage());
-
-    peer_.reset(new Peer("host", 6969));
-
-    messageFactory_.reset(new MockBtMessageFactory2());
-
-    dispatcher_.reset(new MockBtMessageDispatcher());
-
-    requestFactory_.reset(new DefaultBtRequestFactory());
+    pieceStorage_ = make_unique<MockPieceStorage>();
+    peer_ = std::make_shared<Peer>("host", 6969);
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
+    requestFactory_ = make_unique<DefaultBtRequestFactory>();
     requestFactory_->setPieceStorage(pieceStorage_.get());
     requestFactory_->setPeer(peer_);
     requestFactory_->setBtMessageDispatcher(dispatcher_.get());
@@ -107,14 +96,15 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest);
 
-void DefaultBtRequestFactoryTest::testAddTargetPiece() {
+void DefaultBtRequestFactoryTest::testAddTargetPiece()
+{
   {
-    std::shared_ptr<Piece> piece(new Piece(0, 16*1024*10));
+    auto piece = std::make_shared<Piece>(0, 16*1024*10);
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece());
   }
   {
-    std::shared_ptr<Piece> piece(new Piece(1, 16*1024*9));
+    auto piece = std::make_shared<Piece>(1, 16*1024*9);
     piece->completeBlock(0);
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece());
@@ -122,9 +112,10 @@ void DefaultBtRequestFactoryTest::testAddTargetPiece() {
   CPPUNIT_ASSERT_EQUAL((size_t)18, requestFactory_->countMissingBlock());
 }
 
-void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
-  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
-  std::shared_ptr<Piece> piece2(new Piece(1, 16*1024));
+void DefaultBtRequestFactoryTest::testRemoveCompletedPiece()
+{
+  auto piece1 = std::make_shared<Piece>(0, 16*1024);
+  auto piece2 = std::make_shared<Piece>(1, 16*1024);
   piece2->setAllBlock();
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
@@ -135,77 +126,63 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
                        requestFactory_->getTargetPieces().front()->getIndex());
 }
 
-void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
+void DefaultBtRequestFactoryTest::testCreateRequestMessages()
+{
   int PIECE_LENGTH = 16*1024*2;
-  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
+  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-  requestFactory_->createRequestMessages(msgs, 3);
+  auto msgs = requestFactory_->createRequestMessages(3, false);
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  std::vector<std::shared_ptr<BtMessage> >::iterator itr = msgs.begin();
-  auto msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
-  ++itr;
-  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
-  ++itr;
-  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
+  auto msg = msgs[0].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
+  msg = msgs[1].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
+  msg = msgs[2].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
 
   {
-    std::vector<std::shared_ptr<BtMessage> > msgs;
-    requestFactory_->createRequestMessages(msgs, 3);
+    auto msgs = requestFactory_->createRequestMessages(3, false);
     CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
   }
 }
 
-void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
-    (new MockBtMessageDispatcher2());
+void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame()
+{
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
 
   requestFactory_->setBtMessageDispatcher(dispatcher.get());
 
   int PIECE_LENGTH = 16*1024*2;
-  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
+  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-  requestFactory_->createRequestMessagesOnEndGame(msgs, 3);
-
-  std::vector<std::shared_ptr<MockBtRequestMessage> > mmsgs;
-  for(std::vector<std::shared_ptr<BtMessage> >::iterator i = msgs.begin();
-      i != msgs.end(); ++i) {
-    mmsgs.push_back(std::dynamic_pointer_cast<MockBtRequestMessage>(*i));
-  }
+  auto msgs = requestFactory_->createRequestMessages(3, true);
+  std::sort(std::begin(msgs), std::end(msgs), BtRequestMessageSorter());
 
-  std::sort(mmsgs.begin(), mmsgs.end(), SortMockBtRequestMessage());
-
-  CPPUNIT_ASSERT_EQUAL((size_t)3, mmsgs.size());
-  std::vector<std::shared_ptr<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
-  MockBtRequestMessage* msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
-  ++itr;
-  msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
-  ++itr;
-  msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
+  auto msg = msgs[0].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
+  msg = msgs[1].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
+  msg = msgs[2].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
 }
 
-void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
-  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
+void DefaultBtRequestFactoryTest::testRemoveTargetPiece()
+{
+  auto piece1 = std::make_shared<Piece>(0, 16*1024);
 
   requestFactory_->addTargetPiece(piece1);
 
@@ -224,16 +201,15 @@ void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
 
 void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes()
 {
-  std::shared_ptr<Piece> piece1(new Piece(1, 16*1024));
-  std::shared_ptr<Piece> piece3(new Piece(3, 16*1024));
-  std::shared_ptr<Piece> piece5(new Piece(5, 16*1024));
+  auto piece1 = std::make_shared<Piece>(1, 16*1024);
+  auto piece3 = std::make_shared<Piece>(3, 16*1024);
+  auto piece5 = std::make_shared<Piece>(5, 16*1024);
 
   requestFactory_->addTargetPiece(piece3);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece5);
 
-  std::vector<size_t> indexes;
-  requestFactory_->getTargetPieceIndexes(indexes);
+  auto indexes = requestFactory_->getTargetPieceIndexes();
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes.size());
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes[0]);
   CPPUNIT_ASSERT_EQUAL((size_t)1, indexes[1]);
diff --git a/test/MockBtMessageDispatcher.h b/test/MockBtMessageDispatcher.h
index 9d99e61f..7f1aba89 100644
--- a/test/MockBtMessageDispatcher.h
+++ b/test/MockBtMessageDispatcher.h
@@ -12,18 +12,12 @@ namespace aria2 {
 
 class MockBtMessageDispatcher : public BtMessageDispatcher {
 public:
-  std::deque<std::shared_ptr<BtMessage> > messageQueue;
+  std::deque<std::unique_ptr<BtMessage>> messageQueue;
 
   virtual ~MockBtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage) {
-    messageQueue.push_back(btMessage);
-  }
-
-  virtual void addMessageToQueue
-  (const std::vector<std::shared_ptr<BtMessage> >& btMessages)
-  {
-    std::copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
+  virtual void addMessageToQueue(std::unique_ptr<BtMessage> btMessage) {
+    messageQueue.push_back(std::move(btMessage));
   }
 
   virtual void sendMessages() {}
diff --git a/test/MockBtMessageFactory.h b/test/MockBtMessageFactory.h
index 79c035bd..b4572e93 100644
--- a/test/MockBtMessageFactory.h
+++ b/test/MockBtMessageFactory.h
@@ -3,6 +3,24 @@
 
 #include "BtMessageFactory.h"
 
+#include "BtHandshakeMessage.h"
+#include "BtRequestMessage.h"
+#include "BtCancelMessage.h"
+#include "BtPieceMessage.h"
+#include "BtHaveMessage.h"
+#include "BtChokeMessage.h"
+#include "BtUnchokeMessage.h"
+#include "BtInterestedMessage.h"
+#include "BtNotInterestedMessage.h"
+#include "BtBitfieldMessage.h"
+#include "BtKeepAliveMessage.h"
+#include "BtHaveAllMessage.h"
+#include "BtHaveNoneMessage.h"
+#include "BtRejectMessage.h"
+#include "BtAllowedFastMessage.h"
+#include "BtPortMessage.h"
+#include "BtExtendedMessage.h"
+
 namespace aria2 {
 
 class ExtensionMessage;
@@ -13,91 +31,92 @@ public:
 
   virtual ~MockBtMessageFactory() {}
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtMessage>{};
   };
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) {
-    return std::shared_ptr<BtHandshakeMessage>();
+    return std::unique_ptr<BtHandshakeMessage>{};
   }
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) {
-    return std::shared_ptr<BtHandshakeMessage>();
+    return std::unique_ptr<BtHandshakeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRequestMessage>
   createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtRequestMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtCancelMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtCancelMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtPieceMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtPieceMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index) {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveMessage> createHaveMessage(size_t index) {
+    return std::unique_ptr<BtHaveMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createChokeMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtChokeMessage> createChokeMessage() {
+    return std::unique_ptr<BtChokeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createUnchokeMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtUnchokeMessage> createUnchokeMessage() {
+    return std::unique_ptr<BtUnchokeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createInterestedMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtInterestedMessage> createInterestedMessage() {
+    return std::unique_ptr<BtInterestedMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createNotInterestedMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtNotInterestedMessage> createNotInterestedMessage() {
+    return std::unique_ptr<BtNotInterestedMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createBitfieldMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtBitfieldMessage> createBitfieldMessage() {
+    return std::unique_ptr<BtBitfieldMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createKeepAliveMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtKeepAliveMessage> createKeepAliveMessage() {
+    return std::unique_ptr<BtKeepAliveMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveAllMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveAllMessage> createHaveAllMessage() {
+    return std::unique_ptr<BtHaveAllMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveNoneMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveNoneMessage> createHaveNoneMessage() {
+    return std::unique_ptr<BtHaveNoneMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRejectMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtRejectMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index) {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtAllowedFastMessage> createAllowedFastMessage
+  (size_t index) {
+    return std::unique_ptr<BtAllowedFastMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port)
+  virtual std::unique_ptr<BtPortMessage> createPortMessage(uint16_t port)
   {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtPortMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
   {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtExtendedMessage>{};
   }
 };
 
diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h
index ff198155..70e9f740 100644
--- a/test/MockBtRequestFactory.h
+++ b/test/MockBtRequestFactory.h
@@ -2,6 +2,7 @@
 #define D_MOCK_BT_REQUEST_FACTORY_H
 
 #include "BtRequestFactory.h"
+#include "BtRequestMessage.h"
 
 namespace aria2 {
 
@@ -23,13 +24,16 @@ public:
 
   virtual void doChokedAction() {}
 
-  virtual void createRequestMessages
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
+  virtual std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessages
+  (size_t max, bool endGame)
+  {
+    return std::vector<std::unique_ptr<BtRequestMessage>>{};
+  }
 
-  virtual void createRequestMessagesOnEndGame
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
-
-  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const {}
+  virtual std::vector<size_t> getTargetPieceIndexes() const
+  {
+    return std::vector<size_t>{};
+  }
 };
 
 } // namespace aria2
diff --git a/test/MockExtensionMessage.h b/test/MockExtensionMessage.h
index 45dcb957..cf23693a 100644
--- a/test/MockExtensionMessage.h
+++ b/test/MockExtensionMessage.h
@@ -15,27 +15,28 @@ public:
   MockExtensionMessage(const std::string& extensionName,
                        uint8_t extensionMessageID,
                        const unsigned char* data,
-                       size_t length):extensionName_(extensionName),
-                                      extensionMessageID_(extensionMessageID),
-                                      data_(&data[0], &data[length]),
-                                      doReceivedActionCalled_(false) {}
+                       size_t length)
+    : extensionName_{extensionName},
+      extensionMessageID_{extensionMessageID},
+      data_{&data[0], &data[length]},
+      doReceivedActionCalled_{false}
+  {}
 
   MockExtensionMessage(const std::string& extensionName,
                        uint8_t extensionMessageID,
-                       const std::string& data):
-    extensionName_(extensionName),
-    extensionMessageID_(extensionMessageID),
-    data_(data),
-    doReceivedActionCalled_(false) {}
-
-  virtual ~MockExtensionMessage() {}
+                       const std::string& data)
+    : extensionName_{extensionName},
+      extensionMessageID_{extensionMessageID},
+      data_{data},
+      doReceivedActionCalled_{false}
+  {}
 
   virtual std::string getPayload()
   {
     return data_;
   }
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }
diff --git a/test/UTMetadataRequestExtensionMessageTest.cc b/test/UTMetadataRequestExtensionMessageTest.cc
index bc7007dd..c77215b2 100644
--- a/test/UTMetadataRequestExtensionMessageTest.cc
+++ b/test/UTMetadataRequestExtensionMessageTest.cc
@@ -32,28 +32,29 @@ class UTMetadataRequestExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 public:
   std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<WrapExtBtMessageFactory> messageFactory_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<WrapExtBtMessageFactory> messageFactory_;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
   std::shared_ptr<Peer> peer_;
 
   void setUp()
   {
-    messageFactory_.reset(new WrapExtBtMessageFactory());
-    dispatcher_.reset(new MockBtMessageDispatcher());
-    dctx_.reset(new DownloadContext());
+    messageFactory_ = make_unique<WrapExtBtMessageFactory>();
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
+    dctx_ = std::make_shared<DownloadContext>();
     dctx_->setAttribute(CTX_ATTR_BT, make_unique<TorrentAttribute>());
-    peer_.reset(new Peer("host", 6880));
+    peer_ = std::make_shared<Peer>("host", 6880);
     peer_->allocateSessionResource(0, 0);
     peer_->setExtension(ExtensionMessageRegistry::UT_METADATA, 1);
   }
 
   template<typename T>
-  std::shared_ptr<T> getFirstDispatchedMessage()
+  const T* getFirstDispatchedMessage()
   {
-    auto wrapmsg = std::dynamic_pointer_cast<WrapExtBtMessage>
-      (dispatcher_->messageQueue.front());
-
-    return std::dynamic_pointer_cast<T>(wrapmsg->m_);
+    CPPUNIT_ASSERT(BtExtendedMessage::ID ==
+                   dispatcher_->messageQueue.front()->getId());
+    auto msg = static_cast<const BtExtendedMessage*>
+      (dispatcher_->messageQueue.front().get());
+    return dynamic_cast<const T*>(msg->getExtensionMessage().get());
   }
 
   void testGetExtensionMessageID();
@@ -106,8 +107,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_reject()
   msg.setBtMessageDispatcher(dispatcher_.get());
   msg.doReceivedAction();
 
-  std::shared_ptr<UTMetadataRejectExtensionMessage> m =
-    getFirstDispatchedMessage<UTMetadataRejectExtensionMessage>();
+  auto m = getFirstDispatchedMessage<UTMetadataRejectExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
   CPPUNIT_ASSERT_EQUAL((size_t)10, m->getIndex());
@@ -132,8 +132,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data()
 
   msg.doReceivedAction();
 
-  std::shared_ptr<UTMetadataDataExtensionMessage> m =
-    getFirstDispatchedMessage<UTMetadataDataExtensionMessage>();
+  auto m = getFirstDispatchedMessage<UTMetadataDataExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getIndex());
diff --git a/test/UTMetadataRequestFactoryTest.cc b/test/UTMetadataRequestFactoryTest.cc
index d5b3654d..0f422bb2 100644
--- a/test/UTMetadataRequestFactoryTest.cc
+++ b/test/UTMetadataRequestFactoryTest.cc
@@ -66,16 +66,14 @@ void UTMetadataRequestFactoryTest::testCreate()
     (new UTMetadataRequestTracker());
   factory.setUTMetadataRequestTracker(tracker.get());
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-
-  factory.create(msgs, 1, ps);
+  auto msgs = factory.create(1, ps);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
 
-  factory.create(msgs, 1, ps);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, msgs.size());
+  msgs = factory.create(1, ps);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
 
-  factory.create(msgs, 1, ps);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, msgs.size());
+  msgs = factory.create(1, ps);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msgs.size());
 }
 
 } // namespace aria2
diff --git a/test/extension_message_test_helper.h b/test/extension_message_test_helper.h
index 5cef2241..c0d432f1 100644
--- a/test/extension_message_test_helper.h
+++ b/test/extension_message_test_helper.h
@@ -1,19 +1,17 @@
 #ifndef D_EXTENSION_MESSAGE_TEST_HELPER_H
 #define D_EXTENSION_MESSAGE_TEST_HELPER_H
 
-#include "MockBtMessage.h"
 #include "MockBtMessageFactory.h"
 
 namespace aria2 {
 
-typedef WrapBtMessage<ExtensionMessage> WrapExtBtMessage;
-
 class WrapExtBtMessageFactory:public MockBtMessageFactory {
 public:
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
+    override
   {
-    return std::shared_ptr<BtMessage>(new WrapExtBtMessage(extmsg));
+    return make_unique<BtExtendedMessage>(extmsg);
   }
 };