src/net/tools/quic/test_tools/quic_test_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/tools/quic/test_tools/quic_test_utils.h"
   6
   7 #include "net/quic/quic_connection.h"
   8 #include "net/quic/test_tools/quic_connection_peer.h"
   9 #include "net/quic/test_tools/quic_test_utils.h"
  10 #include "net/tools/quic/quic_epoll_connection_helper.h"
  11
  12 using base::StringPiece;
  13 using net::test::MakeAckFrame;
  14 using net::test::MockHelper;
  15 using net::test::QuicConnectionPeer;
  16
  17 namespace net {
  18 namespace tools {
  19 namespace test {
  20
  21 namespace {
  22 class NiceMockPacketWriterFactory
  23     : public QuicConnection::PacketWriterFactory {
  24  public:
  25   NiceMockPacketWriterFactory() {}
  26   virtual ~NiceMockPacketWriterFactory() {}
  27
  28   virtual QuicPacketWriter* Create(
  29       QuicConnection* /*connection*/) const OVERRIDE {
  30     return new testing::NiceMock<MockPacketWriter>();
  31   }
  32
  33  private:
  34   DISALLOW_COPY_AND_ASSIGN(NiceMockPacketWriterFactory);
  35 };
  36 }  // namespace
  37
  38 MockConnection::MockConnection(bool is_server)
  39     : QuicConnection(kTestConnectionId,
  40                      IPEndPoint(net::test::Loopback4(), kTestPort),
  41                      new testing::NiceMock<MockHelper>(),
  42                      NiceMockPacketWriterFactory(),
  43                      /* owns_writer= */ true,
  44                      is_server, QuicSupportedVersions()),
  45       helper_(helper()) {
  46 }
  47
  48 MockConnection::MockConnection(IPEndPoint address,
  49                                bool is_server)
  50     : QuicConnection(kTestConnectionId, address,
  51                      new testing::NiceMock<MockHelper>(),
  52                      NiceMockPacketWriterFactory(),
  53                      /* owns_writer= */ true,
  54                      is_server, QuicSupportedVersions()),
  55       helper_(helper()) {
  56 }
  57
  58 MockConnection::MockConnection(QuicConnectionId connection_id,
  59                                bool is_server)
  60     : QuicConnection(connection_id,
  61                      IPEndPoint(net::test::Loopback4(), kTestPort),
  62                      new testing::NiceMock<MockHelper>(),
  63                      NiceMockPacketWriterFactory(),
  64                      /* owns_writer= */ true,
  65                      is_server, QuicSupportedVersions()),
  66       helper_(helper()) {
  67 }
  68
  69 MockConnection::MockConnection(bool is_server,
  70                                const QuicVersionVector& supported_versions)
  71     : QuicConnection(kTestConnectionId,
  72                      IPEndPoint(net::test::Loopback4(), kTestPort),
  73                      new testing::NiceMock<MockHelper>(),
  74                      NiceMockPacketWriterFactory(),
  75                      /* owns_writer= */ true,
  76                      is_server, QuicSupportedVersions()),
  77       helper_(helper()) {
  78 }
  79
  80 MockConnection::~MockConnection() {
  81 }
  82
  83 void MockConnection::AdvanceTime(QuicTime::Delta delta) {
  84   static_cast<MockHelper*>(helper())->AdvanceTime(delta);
  85 }
  86
  87 QuicAckFrame MakeAckFrameWithNackRanges(
  88     size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) {
  89   QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
  90   // Add enough missing packets to get num_nack_ranges nack ranges.
  91   for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
  92     ack.missing_packets.insert(least_unacked + i);
  93   }
  94   return ack;
  95 }
  96
  97 TestSession::TestSession(QuicConnection* connection,
  98                          const QuicConfig& config)
  99     : QuicSession(connection, config),
 100       crypto_stream_(NULL) {
 101   InitializeSession();
 102 }
 103
 104 TestSession::~TestSession() {}
 105
 106 void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
 107   crypto_stream_ = stream;
 108 }
 109
 110 QuicCryptoStream* TestSession::GetCryptoStream() {
 111   return crypto_stream_;
 112 }
 113
 114 MockPacketWriter::MockPacketWriter() {
 115 }
 116
 117 MockPacketWriter::~MockPacketWriter() {
 118 }
 119
 120 MockQuicServerSessionVisitor::MockQuicServerSessionVisitor() {
 121 }
 122
 123 MockQuicServerSessionVisitor::~MockQuicServerSessionVisitor() {
 124 }
 125
 126 MockAckNotifierDelegate::MockAckNotifierDelegate() {
 127 }
 128
 129 MockAckNotifierDelegate::~MockAckNotifierDelegate() {
 130 }
 131
 132 TestWriterFactory::TestWriterFactory() : current_writer_(NULL) {}
 133 TestWriterFactory::~TestWriterFactory() {}
 134
 135 QuicPacketWriter* TestWriterFactory::Create(QuicPacketWriter* writer,
 136                                             QuicConnection* connection) {
 137   return new PerConnectionPacketWriter(this, writer, connection);
 138 }
 139
 140 void TestWriterFactory::OnPacketSent(WriteResult result) {
 141   if (current_writer_ != NULL && result.status == WRITE_STATUS_ERROR) {
 142     current_writer_->connection()->OnWriteError(result.error_code);
 143     current_writer_ = NULL;
 144   }
 145 }
 146
 147 void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) {
 148   if (current_writer_ == writer) {
 149     current_writer_ = NULL;
 150   }
 151 }
 152
 153 TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter(
 154     TestWriterFactory* factory,
 155     QuicPacketWriter* writer,
 156     QuicConnection* connection)
 157     : QuicPerConnectionPacketWriter(writer, connection),
 158       factory_(factory) {
 159 }
 160
 161 TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() {
 162   factory_->Unregister(this);
 163 }
 164
 165 WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
 166     const char* buffer,
 167     size_t buf_len,
 168     const IPAddressNumber& self_address,
 169     const IPEndPoint& peer_address) {
 170   // A DCHECK(factory_current_writer_ == NULL) would be wrong here -- this class
 171   // may be used in a setting where connection()->OnPacketSent() is called in a
 172   // different way, so TestWriterFactory::OnPacketSent might never be called.
 173   factory_->current_writer_ = this;
 174   return QuicPerConnectionPacketWriter::WritePacket(buffer,
 175                                                     buf_len,
 176                                                     self_address,
 177                                                     peer_address);
 178 }
 179
 180 }  // namespace test
 181 }  // namespace tools
 182 }  // namespace net