Home | History | Annotate | Download | only in test_tools 
      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
    183