← Back to branch summary

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

« back to all changes in this revision

Viewing changes to test/DefaultBtRequestFactoryTest.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/DefaultBtRequestFactoryTest.cc
27
27
  CPPUNIT_TEST(testGetTargetPieceIndexes);
28
28
  CPPUNIT_TEST_SUITE_END();
29
29
private:
30
 
  SharedHandle<Peer> peer_;
31
 
  SharedHandle<DefaultBtRequestFactory> requestFactory_;
32
 
  SharedHandle<DownloadContext> dctx_;
33
 
  SharedHandle<MockPieceStorage> pieceStorage_;
34
 
  SharedHandle<MockBtMessageFactory> messageFactory_;
35
 
  SharedHandle<MockBtMessageDispatcher> dispatcher_;
 
30
  std::shared_ptr<Peer> peer_;
 
31
  std::unique_ptr<DefaultBtRequestFactory> requestFactory_;
 
32
  std::unique_ptr<MockPieceStorage> pieceStorage_;
 
33
  std::unique_ptr<MockBtMessageFactory> messageFactory_;
 
34
  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
36
35
public:
37
36
  void testAddTargetPiece();
38
37
  void testRemoveCompletedPiece();
50
49
      index(index), blockIndex(blockIndex) {}
51
50
  };
52
51
 
53
 
  typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle;
54
 
 
55
52
  class MockBtMessageFactory2 : public MockBtMessageFactory {
56
53
  public:
57
 
    virtual SharedHandle<BtMessage>
58
 
    createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex) {
59
 
      return SharedHandle<BtMessage>
60
 
        (new MockBtRequestMessage(piece->getIndex(), blockIndex));
 
54
    virtual std::unique_ptr<BtRequestMessage>
 
55
    createRequestMessage(const std::shared_ptr<Piece>& piece,
 
56
                         size_t blockIndex) CXX11_OVERRIDE
 
57
    {
 
58
      return make_unique<BtRequestMessage>(piece->getIndex(), 0, 0,
 
59
                                           blockIndex);
61
60
    }
62
61
  };
63
62
 
64
63
  class MockBtMessageDispatcher2 : public MockBtMessageDispatcher {
65
64
  public:
66
 
    virtual bool isOutstandingRequest(size_t index, size_t blockIndex) {
 
65
    virtual bool isOutstandingRequest(size_t index, size_t blockIndex)
 
66
      CXX11_OVERRIDE
 
67
    {
67
68
      return index == 0 && blockIndex == 0;
68
69
    }
69
70
  };
70
71
 
71
 
  class SortMockBtRequestMessage {
 
72
  class BtRequestMessageSorter {
72
73
  public:
73
 
    bool operator()(const SharedHandle<MockBtRequestMessage>& a,
74
 
                    const SharedHandle<MockBtRequestMessage>& b) {
75
 
      if(a->index < b->index) {
76
 
        return true;
77
 
      } else if(b->index < a->index) {
78
 
        return false;
79
 
      } else if(a->blockIndex < b->blockIndex) {
80
 
        return true;
81
 
      } else if(b->blockIndex < a->blockIndex) {
82
 
        return false;
83
 
      } else {
84
 
        return true;
85
 
      }
 
74
    bool operator()(const std::unique_ptr<BtRequestMessage>& a,
 
75
                    const std::unique_ptr<BtRequestMessage>& b)
 
76
    {
 
77
      return a->getIndex() < b->getIndex() ||
 
78
        (a->getIndex() == b->getIndex() &&
 
79
         a->getBlockIndex() < b->getBlockIndex());
86
80
    }
87
81
  };
88
82
 
89
83
  void setUp()
90
84
  {
91
 
    pieceStorage_.reset(new MockPieceStorage());
92
 
 
93
 
    peer_.reset(new Peer("host", 6969));
94
 
 
95
 
    messageFactory_.reset(new MockBtMessageFactory2());
96
 
 
97
 
    dispatcher_.reset(new MockBtMessageDispatcher());
98
 
 
99
 
    requestFactory_.reset(new DefaultBtRequestFactory());
100
 
    requestFactory_->setPieceStorage(pieceStorage_);
 
85
    pieceStorage_ = make_unique<MockPieceStorage>();
 
86
    peer_ = std::make_shared<Peer>("host", 6969);
 
87
    messageFactory_ = make_unique<MockBtMessageFactory2>();
 
88
    dispatcher_ = make_unique<MockBtMessageDispatcher>();
 
89
    requestFactory_ = make_unique<DefaultBtRequestFactory>();
 
90
    requestFactory_->setPieceStorage(pieceStorage_.get());
101
91
    requestFactory_->setPeer(peer_);
102
92
    requestFactory_->setBtMessageDispatcher(dispatcher_.get());
103
93
    requestFactory_->setBtMessageFactory(messageFactory_.get());
107
97
 
108
98
CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest);
109
99
 
110
 
void DefaultBtRequestFactoryTest::testAddTargetPiece() {
 
100
void DefaultBtRequestFactoryTest::testAddTargetPiece()
 
101
{
111
102
  {
112
 
    SharedHandle<Piece> piece(new Piece(0, 16*1024*10));
 
103
    auto piece = std::make_shared<Piece>(0, 16*1024*10);
113
104
    requestFactory_->addTargetPiece(piece);
114
105
    CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece());
115
106
  }
116
107
  {
117
 
    SharedHandle<Piece> piece(new Piece(1, 16*1024*9));
 
108
    auto piece = std::make_shared<Piece>(1, 16*1024*9);
118
109
    piece->completeBlock(0);
119
110
    requestFactory_->addTargetPiece(piece);
120
111
    CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece());
122
113
  CPPUNIT_ASSERT_EQUAL((size_t)18, requestFactory_->countMissingBlock());
123
114
}
124
115
 
125
 
void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
126
 
  SharedHandle<Piece> piece1(new Piece(0, 16*1024));
127
 
  SharedHandle<Piece> piece2(new Piece(1, 16*1024));
 
116
void DefaultBtRequestFactoryTest::testRemoveCompletedPiece()
 
117
{
 
118
  auto piece1 = std::make_shared<Piece>(0, 16*1024);
 
119
  auto piece2 = std::make_shared<Piece>(1, 16*1024);
128
120
  piece2->setAllBlock();
129
121
  requestFactory_->addTargetPiece(piece1);
130
122
  requestFactory_->addTargetPiece(piece2);
135
127
                       requestFactory_->getTargetPieces().front()->getIndex());
136
128
}
137
129
 
138
 
void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
 
130
void DefaultBtRequestFactoryTest::testCreateRequestMessages()
 
131
{
139
132
  int PIECE_LENGTH = 16*1024*2;
140
 
  SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH));
141
 
  SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH));
 
133
  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
 
134
  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
142
135
  requestFactory_->addTargetPiece(piece1);
143
136
  requestFactory_->addTargetPiece(piece2);
144
137
 
145
 
  std::vector<SharedHandle<BtMessage> > msgs;
146
 
  requestFactory_->createRequestMessages(msgs, 3);
 
138
  auto msgs = requestFactory_->createRequestMessages(3, false);
147
139
 
148
140
  CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
149
 
  std::vector<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
150
 
  SharedHandle<MockBtRequestMessage> msg =
151
 
    dynamic_pointer_cast<MockBtRequestMessage>(*itr);
152
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
153
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
154
 
  ++itr;
155
 
  msg = dynamic_pointer_cast<MockBtRequestMessage>(*itr);
156
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
157
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
158
 
  ++itr;
159
 
  msg = dynamic_pointer_cast<MockBtRequestMessage>(*itr);
160
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
161
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
 
141
  auto msg = msgs[0].get();
 
142
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
 
143
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
 
144
  msg = msgs[1].get();
 
145
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
 
146
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
 
147
  msg = msgs[2].get();
 
148
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
 
149
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
162
150
 
163
151
  {
164
 
    std::vector<SharedHandle<BtMessage> > msgs;
165
 
    requestFactory_->createRequestMessages(msgs, 3);
 
152
    auto msgs = requestFactory_->createRequestMessages(3, false);
166
153
    CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
167
154
  }
168
155
}
169
156
 
170
 
void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
171
 
  SharedHandle<MockBtMessageDispatcher2> dispatcher
172
 
    (new MockBtMessageDispatcher2());
 
157
void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame()
 
158
{
 
159
  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
173
160
 
174
161
  requestFactory_->setBtMessageDispatcher(dispatcher.get());
175
162
 
176
163
  int PIECE_LENGTH = 16*1024*2;
177
 
  SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH));
178
 
  SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH));
 
164
  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
 
165
  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
179
166
  requestFactory_->addTargetPiece(piece1);
180
167
  requestFactory_->addTargetPiece(piece2);
181
168
 
182
 
  std::vector<SharedHandle<BtMessage> > msgs;
183
 
  requestFactory_->createRequestMessagesOnEndGame(msgs, 3);
184
 
 
185
 
  std::vector<SharedHandle<MockBtRequestMessage> > mmsgs;
186
 
  for(std::vector<SharedHandle<BtMessage> >::iterator i = msgs.begin();
187
 
      i != msgs.end(); ++i) {
188
 
    mmsgs.push_back(dynamic_pointer_cast<MockBtRequestMessage>(*i));
189
 
  }
190
 
 
191
 
  std::sort(mmsgs.begin(), mmsgs.end(), SortMockBtRequestMessage());
192
 
 
193
 
  CPPUNIT_ASSERT_EQUAL((size_t)3, mmsgs.size());
194
 
  std::vector<SharedHandle<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
195
 
  MockBtRequestMessage* msg = (*itr).get();
196
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
197
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
198
 
  ++itr;
199
 
  msg = (*itr).get();
200
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
201
 
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
202
 
  ++itr;
203
 
  msg = (*itr).get();
204
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
205
 
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
 
169
  auto msgs = requestFactory_->createRequestMessages(3, true);
 
170
  std::sort(std::begin(msgs), std::end(msgs), BtRequestMessageSorter());
 
171
 
 
172
  CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
 
173
  auto msg = msgs[0].get();
 
174
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
 
175
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
 
176
  msg = msgs[1].get();
 
177
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
 
178
  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
 
179
  msg = msgs[2].get();
 
180
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
 
181
  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
206
182
}
207
183
 
208
 
void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
209
 
  SharedHandle<Piece> piece1(new Piece(0, 16*1024));
 
184
void DefaultBtRequestFactoryTest::testRemoveTargetPiece()
 
185
{
 
186
  auto piece1 = std::make_shared<Piece>(0, 16*1024);
210
187
 
211
188
  requestFactory_->addTargetPiece(piece1);
212
189
 
225
202
 
226
203
void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes()
227
204
{
228
 
  SharedHandle<Piece> piece1(new Piece(1, 16*1024));
229
 
  SharedHandle<Piece> piece3(new Piece(3, 16*1024));
230
 
  SharedHandle<Piece> piece5(new Piece(5, 16*1024));
 
205
  auto piece1 = std::make_shared<Piece>(1, 16*1024);
 
206
  auto piece3 = std::make_shared<Piece>(3, 16*1024);
 
207
  auto piece5 = std::make_shared<Piece>(5, 16*1024);
231
208
 
232
209
  requestFactory_->addTargetPiece(piece3);
233
210
  requestFactory_->addTargetPiece(piece1);
234
211
  requestFactory_->addTargetPiece(piece5);
235
212
 
236
 
  std::vector<size_t> indexes;
237
 
  requestFactory_->getTargetPieceIndexes(indexes);
 
213
  auto indexes = requestFactory_->getTargetPieceIndexes();
238
214
  CPPUNIT_ASSERT_EQUAL((size_t)3, indexes.size());
239
215
  CPPUNIT_ASSERT_EQUAL((size_t)3, indexes[0]);
240
216
  CPPUNIT_ASSERT_EQUAL((size_t)1, indexes[1]);