net/tools/quic/test_tools/quic_test_utils.h

   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 // Common utilities for Quic tests
   6
   7 #ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
   8 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
   9
  10 #include <string>
  11
  12 #include "base/strings/string_piece.h"
  13 #include "net/quic/proto/cached_network_parameters.pb.h"
  14 #include "net/quic/quic_connection.h"
  15 #include "net/quic/quic_packet_writer.h"
  16 #include "net/quic/quic_session.h"
  17 #include "net/spdy/spdy_framer.h"
  18 #include "net/tools/quic/quic_dispatcher.h"
  19 #include "net/tools/quic/quic_per_connection_packet_writer.h"
  20 #include "net/tools/quic/quic_server_session.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22
  23 namespace net {
  24
  25 class EpollServer;
  26 class IPEndPoint;
  27
  28 namespace tools {
  29 namespace test {
  30
  31 static const QuicConnectionId kTestConnectionId = 42;
  32 static const uint16 kTestPort = 123;
  33 static const uint32 kInitialStreamFlowControlWindowForTest =
  34     1024 * 1024;  // 1 MB
  35 static const uint32 kInitialSessionFlowControlWindowForTest =
  36     1536 * 1024;  // 1.5 MB
  37
  38 // Testing convenience method to construct a QuicAckFrame with |num_nack_ranges|
  39 // nack ranges of width 1 packet, starting from |least_unacked|.
  40 QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges,
  41                                         QuicPacketSequenceNumber least_unacked);
  42
  43 class MockPacketWriter : public QuicPacketWriter {
  44  public:
  45   MockPacketWriter();
  46   virtual ~MockPacketWriter();
  47
  48   MOCK_METHOD4(WritePacket,
  49                WriteResult(const char* buffer,
  50                            size_t buf_len,
  51                            const IPAddressNumber& self_address,
  52                            const IPEndPoint& peer_address));
  53   MOCK_CONST_METHOD0(IsWriteBlockedDataBuffered, bool());
  54   MOCK_CONST_METHOD0(IsWriteBlocked, bool());
  55   MOCK_METHOD0(SetWritable, void());
  56
  57  private:
  58   DISALLOW_COPY_AND_ASSIGN(MockPacketWriter);
  59 };
  60
  61 class MockQuicServerSessionVisitor : public QuicServerSessionVisitor {
  62  public:
  63   MockQuicServerSessionVisitor();
  64   virtual ~MockQuicServerSessionVisitor();
  65   MOCK_METHOD2(OnConnectionClosed, void(QuicConnectionId connection_id,
  66                                         QuicErrorCode error));
  67   MOCK_METHOD1(OnWriteBlocked,
  68                void(QuicBlockedWriterInterface* blocked_writer));
  69   MOCK_METHOD1(OnConnectionAddedToTimeWaitList,
  70                void(QuicConnectionId connection_id));
  71   MOCK_METHOD1(OnConnectionRemovedFromTimeWaitList,
  72                void(QuicConnectionId connection_id));
  73
  74  private:
  75   DISALLOW_COPY_AND_ASSIGN(MockQuicServerSessionVisitor);
  76 };
  77
  78 class MockAckNotifierDelegate : public QuicAckNotifier::DelegateInterface {
  79  public:
  80   MockAckNotifierDelegate();
  81
  82   MOCK_METHOD3(OnAckNotification,
  83                void(int num_retransmitted_packets,
  84                     int num_retransmitted_bytes,
  85                     QuicTime::Delta delta_largest_observed));
  86
  87  protected:
  88   // Object is ref counted.
  89   virtual ~MockAckNotifierDelegate();
  90
  91  private:
  92   DISALLOW_COPY_AND_ASSIGN(MockAckNotifierDelegate);
  93 };
  94
  95 // Creates per-connection packet writers that register themselves with the
  96 // TestWriterFactory on each write so that TestWriterFactory::OnPacketSent can
  97 // be routed to the appropriate QuicConnection.
  98 class TestWriterFactory : public QuicDispatcher::PacketWriterFactory {
  99  public:
 100   TestWriterFactory();
 101   ~TestWriterFactory() override;
 102
 103   QuicPacketWriter* Create(QuicPacketWriter* writer,
 104                            QuicConnection* connection) override;
 105
 106   // Calls OnPacketSent on the last QuicConnection to write through one of the
 107   // packet writers created by this factory.
 108   void OnPacketSent(WriteResult result);
 109
 110  private:
 111   class PerConnectionPacketWriter : public QuicPerConnectionPacketWriter {
 112    public:
 113     PerConnectionPacketWriter(TestWriterFactory* factory,
 114                               QuicPacketWriter* writer,
 115                               QuicConnection* connection);
 116     ~PerConnectionPacketWriter() override;
 117
 118     WriteResult WritePacket(const char* buffer,
 119                             size_t buf_len,
 120                             const IPAddressNumber& self_address,
 121                             const IPEndPoint& peer_address) override;
 122
 123    private:
 124     TestWriterFactory* factory_;
 125   };
 126
 127   // If an asynchronous write is happening and |writer| gets deleted, this
 128   // clears the pointer to it to prevent use-after-free.
 129   void Unregister(PerConnectionPacketWriter* writer);
 130
 131   PerConnectionPacketWriter* current_writer_;
 132 };
 133
 134 class MockTimeWaitListManager : public QuicTimeWaitListManager {
 135  public:
 136   MockTimeWaitListManager(QuicPacketWriter* writer,
 137                           QuicServerSessionVisitor* visitor,
 138                           QuicConnectionHelperInterface* helper);
 139   ~MockTimeWaitListManager() override;
 140
 141   MOCK_METHOD4(AddConnectionIdToTimeWait,
 142                void(QuicConnectionId connection_id,
 143                     QuicVersion version,
 144                     bool connection_rejected_statelessly,
 145                     QuicEncryptedPacket* close_packet));
 146
 147   void QuicTimeWaitListManager_AddConnectionIdToTimeWait(
 148       QuicConnectionId connection_id,
 149       QuicVersion version,
 150       bool connection_rejected_statelessly,
 151       QuicEncryptedPacket* close_packet) {
 152     QuicTimeWaitListManager::AddConnectionIdToTimeWait(
 153         connection_id, version, connection_rejected_statelessly, close_packet);
 154   }
 155
 156   MOCK_METHOD5(ProcessPacket,
 157                void(const IPEndPoint& server_address,
 158                     const IPEndPoint& client_address,
 159                     QuicConnectionId connection_id,
 160                     QuicPacketSequenceNumber sequence_number,
 161                     const QuicEncryptedPacket& packet));
 162 };
 163
 164 }  // namespace test
 165 }  // namespace tools
 166 }  // namespace net
 167
 168 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_