← Back to branch summary

~ubuntu-branches/ubuntu/wily/aria2/wily-proposed

« back to all changes in this revision

Viewing changes to test/BtPieceMessageTest.cc

  • Committer: Package Import Robot
  • Author(s): Kartik Mistry, Kartik Mistry, Patrick Ruckstuhl
  • Date: 2013-09-22 18:52:14 UTC
  • mfrom: (2.5.19 sid)
  • Revision ID: package-import@ubuntu.com-20130922185214-upeu2ljgeqi7e7oo
Tags: 1.18.0-1
http://bugs.debian.org/697659
http://bugs.debian.org/720977
[ Kartik Mistry ]
* New upstream release.
* debian/control:
  + (really) Set priority to optional from extra (Closes: #697659).
  + wrap-and-sort some fields.

[ Patrick Ruckstuhl ]
* debian/rules:
  + Allow parallel building (Closes: #720977)
* debian/tests, debian/control:
  + autopkgtest infrastructure

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/BtPieceMessageTest.cc
15
15
#include "Piece.h"
16
16
#include "BtHandshakeMessage.h"
17
17
#include "DownloadContext.h"
 
18
#include "BtRejectMessage.h"
18
19
 
19
20
namespace aria2 {
20
21
 
47
48
  void testCancelSendingPieceEvent_invalidate();
48
49
  void testToString();
49
50
 
50
 
  class MockBtMessage2 : public MockBtMessage {
51
 
  public:
52
 
    size_t index;
53
 
    uint32_t begin;
54
 
    size_t length;
55
 
  public:
56
 
    MockBtMessage2(size_t index, uint32_t begin, size_t length):index(index), begin(begin), length(length) {}
57
 
 
58
 
  };
59
 
 
60
51
  class MockBtMessageFactory2 : public MockBtMessageFactory {
61
52
  public:
62
 
    virtual SharedHandle<BtMessage>
 
53
    virtual std::unique_ptr<BtRejectMessage>
63
54
    createRejectMessage(size_t index,
64
55
                        int32_t begin,
65
 
                        int32_t length) {
66
 
      SharedHandle<MockBtMessage2> msg(new MockBtMessage2(index, begin, length));
67
 
      return msg;
 
56
                        int32_t length) CXX11_OVERRIDE
 
57
    {
 
58
      return make_unique<BtRejectMessage>(index, begin, length);
68
59
    }
69
60
  };
70
61
 
71
 
  SharedHandle<DownloadContext> dctx_;
72
 
  SharedHandle<MockBtMessageDispatcher> btMessageDispatcher;
73
 
  SharedHandle<MockBtMessageFactory> btMessageFactory_;
74
 
  SharedHandle<Peer> peer;
75
 
  SharedHandle<BtPieceMessage> msg;
 
62
  std::unique_ptr<DownloadContext> dctx_;
 
63
  std::unique_ptr<MockBtMessageDispatcher> btMessageDispatcher;
 
64
  std::unique_ptr<MockBtMessageFactory> btMessageFactory_;
 
65
  std::shared_ptr<Peer> peer;
 
66
  std::unique_ptr<BtPieceMessage> msg;
76
67
 
77
68
  void setUp() {
78
 
    dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file"));
 
69
    dctx_ = make_unique<DownloadContext>(16*1024, 256*1024, "/path/to/file");
79
70
 
80
 
    peer.reset(new Peer("host", 6969));
 
71
    peer = std::make_shared<Peer>("host", 6969);
81
72
    peer->allocateSessionResource(dctx_->getPieceLength(),
82
73
                                  dctx_->getTotalLength());
83
74
 
84
 
    btMessageDispatcher.reset(new MockBtMessageDispatcher());
85
 
    btMessageFactory_.reset(new MockBtMessageFactory2());
 
75
    btMessageDispatcher = make_unique<MockBtMessageDispatcher>();
 
76
    btMessageFactory_ = make_unique<MockBtMessageFactory2>();
86
77
 
87
 
    msg.reset(new BtPieceMessage());
 
78
    msg = make_unique<BtPieceMessage>();
88
79
    msg->setIndex(1);
89
80
    msg->setBegin(1024);
90
81
    msg->setBlockLength(16*1024);
91
 
    msg->setDownloadContext(dctx_);
 
82
    msg->setDownloadContext(dctx_.get());
92
83
    msg->setPeer(peer);
93
84
    msg->setBtMessageDispatcher(btMessageDispatcher.get());
94
85
    msg->setBtMessageFactory(btMessageFactory_.get());
106
97
  bittorrent::setIntParam(&msg[5], 12345);
107
98
  bittorrent::setIntParam(&msg[9], 256);
108
99
  memcpy(&msg[13], data, sizeof(data));
109
 
  SharedHandle<BtPieceMessage> pm(BtPieceMessage::create(&msg[4], 11));
 
100
  std::shared_ptr<BtPieceMessage> pm(BtPieceMessage::create(&msg[4], 11));
110
101
  CPPUNIT_ASSERT_EQUAL((uint8_t)7, pm->getId());
111
102
  CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
112
103
  CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
166
157
 
167
158
  CPPUNIT_ASSERT(msg->isInvalidate());
168
159
  CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
169
 
  SharedHandle<MockBtMessage2> rej =
170
 
    dynamic_pointer_cast<MockBtMessage2>
171
 
    (btMessageDispatcher->messageQueue.front());
172
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
173
 
  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
174
 
  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
 
160
  auto rej = static_cast<const BtRejectMessage*>
 
161
    (btMessageDispatcher->messageQueue.front().get());
 
162
  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
 
163
  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
 
164
  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
175
165
}
176
166
 
177
167
void BtPieceMessageTest::testChokingEvent_inAmAllowedIndexSet() {
235
225
 
236
226
  CPPUNIT_ASSERT(msg->isInvalidate());
237
227
  CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
238
 
  SharedHandle<MockBtMessage2> rej =
239
 
    dynamic_pointer_cast<MockBtMessage2>
240
 
    (btMessageDispatcher->messageQueue.front());
241
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
242
 
  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
243
 
  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
 
228
  auto rej = static_cast<const BtRejectMessage*>
 
229
    (btMessageDispatcher->messageQueue.front().get());
 
230
  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
 
231
  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
 
232
  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
244
233
}
245
234
 
246
235
void BtPieceMessageTest::testCancelSendingPieceEvent_invalidate() {