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

1 files changed, 85 insertions, 106 deletions

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