← Back to branch summary

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

« back to all changes in this revision

Viewing changes to test/DHTAnnouncePeerMessageTest.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/DHTAnnouncePeerMessageTest.cc
20
20
  CPPUNIT_TEST(testDoReceivedAction);
21
21
  CPPUNIT_TEST_SUITE_END();
22
22
public:
23
 
  void setUp() {}
 
23
  std::shared_ptr<DHTNode> localNode_;
 
24
  std::shared_ptr<DHTNode> remoteNode_;
 
25
 
 
26
  void setUp()
 
27
  {
 
28
    localNode_ = std::make_shared<DHTNode>();
 
29
    remoteNode_ = std::make_shared<DHTNode>();
 
30
  }
24
31
 
25
32
  void tearDown() {}
26
33
 
28
35
  void testDoReceivedAction();
29
36
 
30
37
  class MockDHTMessageFactory2:public MockDHTMessageFactory {
31
 
    virtual SharedHandle<DHTResponseMessage>
32
 
    createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 
38
    virtual std::unique_ptr<DHTAnnouncePeerReplyMessage>
 
39
    createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
33
40
                                   const std::string& transactionID)
 
41
      CXX11_OVERRIDE
34
42
    {
35
 
      return SharedHandle<DHTResponseMessage>
36
 
        (new MockDHTResponseMessage
37
 
         (localNode_, remoteNode, "announce_peer", transactionID));
 
43
      return make_unique<DHTAnnouncePeerReplyMessage>(localNode_, remoteNode,
 
44
                                                      transactionID);
38
45
    }
39
46
  };
40
47
};
44
51
 
45
52
void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
46
53
{
47
 
  SharedHandle<DHTNode> localNode(new DHTNode());
48
 
  SharedHandle<DHTNode> remoteNode(new DHTNode());
49
 
 
50
54
  unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
51
55
  util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
52
56
  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
57
61
  std::string token = "token";
58
62
  uint16_t port = 6881;
59
63
 
60
 
  DHTAnnouncePeerMessage msg(localNode, remoteNode, infoHash, port, token, transactionID);
 
64
  DHTAnnouncePeerMessage msg(localNode_, remoteNode_, infoHash, port, token,
 
65
                             transactionID);
61
66
  msg.setVersion("A200");
62
67
  std::string msgbody = msg.getBencodedMessage();
63
68
 
66
71
  dict.put("v", "A200");
67
72
  dict.put("y", "q");
68
73
  dict.put("q", "announce_peer");
69
 
  SharedHandle<Dict> aDict = Dict::g();
70
 
  aDict->put("id", String::g(localNode->getID(), DHT_ID_LENGTH));
 
74
  auto aDict = Dict::g();
 
75
  aDict->put("id", String::g(localNode_->getID(), DHT_ID_LENGTH));
71
76
  aDict->put("info_hash", String::g(infoHash, DHT_ID_LENGTH));
72
77
  aDict->put("port", Integer::g(port));
73
78
  aDict->put("token", token);
74
 
  dict.put("a", aDict);
 
79
  dict.put("a", std::move(aDict));
75
80
 
76
81
  CPPUNIT_ASSERT_EQUAL(util::percentEncode(bencode2::encode(&dict)),
77
82
                       util::percentEncode(msgbody));
79
84
 
80
85
void DHTAnnouncePeerMessageTest::testDoReceivedAction()
81
86
{
82
 
  SharedHandle<DHTNode> localNode(new DHTNode());
83
 
  SharedHandle<DHTNode> remoteNode(new DHTNode());
84
 
  remoteNode->setIPAddress("192.168.0.1");
85
 
  remoteNode->setPort(6881);
 
87
  remoteNode_->setIPAddress("192.168.0.1");
 
88
  remoteNode_->setPort(6881);
86
89
 
87
90
  unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
88
91
  util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
96
99
 
97
100
  DHTPeerAnnounceStorage peerAnnounceStorage;
98
101
  MockDHTMessageFactory2 factory;
99
 
  factory.setLocalNode(localNode);
 
102
  factory.setLocalNode(localNode_);
100
103
  MockDHTMessageDispatcher dispatcher;
101
104
 
102
 
  DHTAnnouncePeerMessage msg(localNode, remoteNode, infoHash, port, token, transactionID);
 
105
  DHTAnnouncePeerMessage msg(localNode_, remoteNode_, infoHash, port, token,
 
106
                             transactionID);
103
107
  msg.setPeerAnnounceStorage(&peerAnnounceStorage);
104
108
  msg.setMessageFactory(&factory);
105
109
  msg.setMessageDispatcher(&dispatcher);
107
111
  msg.doReceivedAction();
108
112
 
109
113
  CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size());
110
 
  SharedHandle<MockDHTResponseMessage> m
111
 
    (dynamic_pointer_cast<MockDHTResponseMessage>
112
 
     (dispatcher.messageQueue_[0].message_));
113
 
  CPPUNIT_ASSERT(*localNode == *m->getLocalNode());
114
 
  CPPUNIT_ASSERT(*remoteNode == *m->getRemoteNode());
 
114
  auto m = dynamic_cast<DHTAnnouncePeerReplyMessage*>
 
115
    (dispatcher.messageQueue_[0].message_.get());
 
116
  CPPUNIT_ASSERT(*localNode_ == *m->getLocalNode());
 
117
  CPPUNIT_ASSERT(*remoteNode_ == *m->getRemoteNode());
115
118
  CPPUNIT_ASSERT_EQUAL(std::string("announce_peer"), m->getMessageType());
116
119
  CPPUNIT_ASSERT_EQUAL(transactionID, m->getTransactionID());
117
 
  std::vector<SharedHandle<Peer> > peers;
 
120
  std::vector<std::shared_ptr<Peer> > peers;
118
121
  peerAnnounceStorage.getPeers(peers, infoHash);
119
122
  CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
120
123
  {
121
 
    SharedHandle<Peer> peer = peers[0];
 
124
    std::shared_ptr<Peer> peer = peers[0];
122
125
    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->getIPAddress());
123
126
    CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peer->getPort());
124
127
  }