summaryrefslogtreecommitdiff
path: root/test/MockPeerStorage.h
blob: d68715ddb6ab7b7a2e304073ab284dc275750dca (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#ifndef D_MOCK_PEER_STORAGE_H
#  define D_MOCK_PEER_STORAGE_H

#  include "PeerStorage.h"

#  include <algorithm>

#  include "Peer.h"

namespace aria2 {

class MockPeerStorage : public PeerStorage {
private:
  std::deque<std::shared_ptr<Peer>> unusedPeers;
  PeerSet usedPeers;
  std::deque<std::shared_ptr<Peer>> droppedPeers;
  std::vector<std::shared_ptr<Peer>> activePeers;
  int numChokeExecuted_;

public:
  MockPeerStorage() : numChokeExecuted_(0) {}
  virtual ~MockPeerStorage() {}

  virtual bool addPeer(const std::shared_ptr<Peer>& peer) CXX11_OVERRIDE
  {
    unusedPeers.push_back(peer);
    return true;
  }

  virtual void
  addPeer(const std::vector<std::shared_ptr<Peer>>& peers) CXX11_OVERRIDE
  {
    unusedPeers.insert(unusedPeers.end(), peers.begin(), peers.end());
  }

  const std::deque<std::shared_ptr<Peer>>& getUnusedPeers()
  {
    return unusedPeers;
  }

  virtual std::shared_ptr<Peer>
  addAndCheckoutPeer(const std::shared_ptr<Peer>& peer,
                     cuid_t cuid) CXX11_OVERRIDE
  {
    unusedPeers.push_back(peer);
    return nullptr;
  }

  virtual size_t countAllPeer() const CXX11_OVERRIDE
  {
    return unusedPeers.size() + usedPeers.size();
  }

  virtual const std::deque<std::shared_ptr<Peer>>&
  getDroppedPeers() CXX11_OVERRIDE
  {
    return droppedPeers;
  }

  void addDroppedPeer(const std::shared_ptr<Peer>& peer)
  {
    droppedPeers.push_back(peer);
  }

  virtual bool isPeerAvailable() CXX11_OVERRIDE { return false; }

  void setActivePeers(const std::vector<std::shared_ptr<Peer>>& activePeers)
  {
    this->activePeers = activePeers;
  }

  void getActivePeers(std::vector<std::shared_ptr<Peer>>& peers)
  {
    peers.insert(peers.end(), activePeers.begin(), activePeers.end());
  }

  virtual const PeerSet& getUsedPeers() CXX11_OVERRIDE { return usedPeers; }

  virtual bool isBadPeer(const std::string& ipaddr) CXX11_OVERRIDE
  {
    return false;
  }

  virtual void addBadPeer(const std::string& ipaddr) CXX11_OVERRIDE {}

  virtual std::shared_ptr<Peer> checkoutPeer(cuid_t cuid) CXX11_OVERRIDE
  {
    return nullptr;
  }

  virtual void returnPeer(const std::shared_ptr<Peer>& peer) CXX11_OVERRIDE {}

  virtual bool chokeRoundIntervalElapsed() CXX11_OVERRIDE { return false; }

  virtual void executeChoke() CXX11_OVERRIDE { ++numChokeExecuted_; }

  int getNumChokeExecuted() const { return numChokeExecuted_; }
};

#endif // D_MOCK_PEER_STORAGE_H

} // namespace aria2