src/net/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_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
   8 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
   9
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/strings/string_piece.h"
  14 #include "net/quic/congestion_control/send_algorithm_interface.h"
  15 #include "net/quic/quic_connection.h"
  16 #include "net/quic/quic_framer.h"
  17 #include "net/quic/quic_session.h"
  18 #include "net/quic/quic_spdy_decompressor.h"
  19 #include "net/quic/test_tools/mock_clock.h"
  20 #include "net/quic/test_tools/mock_random.h"
  21 #include "net/spdy/spdy_framer.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23
  24 namespace net {
  25
  26 namespace test {
  27
  28 // Upper limit on versions we support.
  29 QuicVersion QuicVersionMax();
  30
  31 // Lower limit on versions we support.
  32 QuicVersion QuicVersionMin();
  33
  34 void CompareCharArraysWithHexError(const std::string& description,
  35                                    const char* actual,
  36                                    const int actual_len,
  37                                    const char* expected,
  38                                    const int expected_len);
  39
  40 // Returns the length of a QuicPacket that is capable of holding either a
  41 // stream frame or a minimal ack frame.  Sets |*payload_length| to the number
  42 // of bytes of stream data that will fit in such a packet.
  43 size_t GetPacketLengthForOneStream(
  44     QuicVersion version,
  45     bool include_version,
  46     QuicSequenceNumberLength sequence_number_length,
  47     InFecGroup is_in_fec_group,
  48     size_t* payload_length);
  49
  50 // Size in bytes of the stream frame fields for an arbitrary StreamID and
  51 // offset and the last frame in a packet.
  52 size_t GetMinStreamFrameSize(QuicVersion version);
  53
  54 // Returns QuicConfig set to default values.
  55 QuicConfig DefaultQuicConfig();
  56
  57 class MockFramerVisitor : public QuicFramerVisitorInterface {
  58  public:
  59   MockFramerVisitor();
  60   ~MockFramerVisitor();
  61
  62   MOCK_METHOD1(OnError, void(QuicFramer* framer));
  63   // The constructor sets this up to return false by default.
  64   MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicVersion version));
  65   MOCK_METHOD0(OnPacket, void());
  66   MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
  67   MOCK_METHOD1(OnVersionNegotiationPacket,
  68                void(const QuicVersionNegotiationPacket& packet));
  69   MOCK_METHOD0(OnRevivedPacket, void());
  70   // The constructor sets this up to return true by default.
  71   MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
  72   MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload));
  73   MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
  74   MOCK_METHOD1(OnAckFrame, bool(const QuicAckFrame& frame));
  75   MOCK_METHOD1(OnCongestionFeedbackFrame,
  76                bool(const QuicCongestionFeedbackFrame& frame));
  77   MOCK_METHOD1(OnFecData, void(const QuicFecData& fec));
  78   MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame));
  79   MOCK_METHOD1(OnConnectionCloseFrame,
  80                bool(const QuicConnectionCloseFrame& frame));
  81   MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame));
  82   MOCK_METHOD0(OnPacketComplete, void());
  83
  84  private:
  85   DISALLOW_COPY_AND_ASSIGN(MockFramerVisitor);
  86 };
  87
  88 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
  89  public:
  90   NoOpFramerVisitor() {}
  91
  92   virtual void OnError(QuicFramer* framer) OVERRIDE {}
  93   virtual void OnPacket() OVERRIDE {}
  94   virtual void OnPublicResetPacket(
  95       const QuicPublicResetPacket& packet) OVERRIDE {}
  96   virtual void OnVersionNegotiationPacket(
  97       const QuicVersionNegotiationPacket& packet) OVERRIDE {}
  98   virtual void OnRevivedPacket() OVERRIDE {}
  99   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
 100   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
 101   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
 102   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
 103   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
 104   virtual bool OnCongestionFeedbackFrame(
 105       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
 106   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
 107   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
 108   virtual bool OnConnectionCloseFrame(
 109       const QuicConnectionCloseFrame& frame) OVERRIDE;
 110   virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
 111   virtual void OnPacketComplete() OVERRIDE {}
 112
 113  private:
 114   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 115 };
 116
 117 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
 118  public:
 119   FramerVisitorCapturingPublicReset();
 120   virtual ~FramerVisitorCapturingPublicReset();
 121
 122   virtual void OnPublicResetPacket(
 123       const QuicPublicResetPacket& packet) OVERRIDE;
 124
 125   const QuicPublicResetPacket public_reset_packet() {
 126     return public_reset_packet_;
 127   }
 128
 129  private:
 130   QuicPublicResetPacket public_reset_packet_;
 131 };
 132
 133 class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
 134  public:
 135   FramerVisitorCapturingFrames();
 136   virtual ~FramerVisitorCapturingFrames();
 137
 138   // NoOpFramerVisitor
 139   virtual void OnVersionNegotiationPacket(
 140       const QuicVersionNegotiationPacket& packet) OVERRIDE;
 141   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
 142   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
 143   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
 144   virtual bool OnCongestionFeedbackFrame(
 145       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
 146   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
 147   virtual bool OnConnectionCloseFrame(
 148       const QuicConnectionCloseFrame& frame) OVERRIDE;
 149   virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
 150
 151   size_t frame_count() const { return frame_count_; }
 152   QuicPacketHeader* header() { return &header_; }
 153   const std::vector<QuicStreamFrame>* stream_frames() const {
 154     return &stream_frames_;
 155   }
 156   const std::vector<string*>& stream_data() const {
 157     return stream_data_;
 158   }
 159   QuicAckFrame* ack() { return ack_.get(); }
 160   QuicCongestionFeedbackFrame* feedback() { return feedback_.get(); }
 161   QuicRstStreamFrame* rst() { return rst_.get(); }
 162   QuicConnectionCloseFrame* close() { return close_.get(); }
 163   QuicGoAwayFrame* goaway() { return goaway_.get(); }
 164   QuicVersionNegotiationPacket* version_negotiation_packet() {
 165     return version_negotiation_packet_.get();
 166   }
 167
 168  private:
 169   size_t frame_count_;
 170   QuicPacketHeader header_;
 171   std::vector<QuicStreamFrame> stream_frames_;
 172   std::vector<std::string*> stream_data_;
 173   scoped_ptr<QuicAckFrame> ack_;
 174   scoped_ptr<QuicCongestionFeedbackFrame> feedback_;
 175   scoped_ptr<QuicRstStreamFrame> rst_;
 176   scoped_ptr<QuicConnectionCloseFrame> close_;
 177   scoped_ptr<QuicGoAwayFrame> goaway_;
 178   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(FramerVisitorCapturingFrames);
 181 };
 182
 183 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
 184  public:
 185   MockConnectionVisitor();
 186   virtual ~MockConnectionVisitor();
 187
 188   MOCK_METHOD1(OnStreamFrames, bool(const std::vector<QuicStreamFrame>& frame));
 189   MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
 190   MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
 191   MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer));
 192   MOCK_METHOD0(OnCanWrite, bool());
 193   MOCK_CONST_METHOD0(HasPendingHandshake, bool());
 194   MOCK_METHOD1(OnSuccessfulVersionNegotiation,
 195                void(const QuicVersion& version));
 196   MOCK_METHOD0(OnConfigNegotiated, void());
 197
 198  private:
 199   DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor);
 200 };
 201
 202 class MockHelper : public QuicConnectionHelperInterface {
 203  public:
 204   MockHelper();
 205   virtual ~MockHelper();
 206
 207   MOCK_METHOD1(SetConnection, void(QuicConnection* connection));
 208   const QuicClock* GetClock() const;
 209   QuicRandom* GetRandomGenerator();
 210   void AdvanceTime(QuicTime::Delta delta);
 211   virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate);
 212
 213  private:
 214   MockClock clock_;
 215   MockRandom random_generator_;
 216 };
 217
 218 class MockConnection : public QuicConnection {
 219  public:
 220   // Uses a MockHelper.
 221   MockConnection(QuicGuid guid, IPEndPoint address, bool is_server);
 222   MockConnection(QuicGuid guid,
 223                  IPEndPoint address,
 224                  QuicConnectionHelperInterface* helper,
 225                  QuicPacketWriter* writer,
 226                  bool is_server);
 227   virtual ~MockConnection();
 228
 229   // If the constructor that uses a MockHelper has been used then this method
 230   // will advance the time of the MockClock.
 231   void AdvanceTime(QuicTime::Delta delta);
 232
 233   MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
 234                                       const IPEndPoint& peer_address,
 235                                       const QuicEncryptedPacket& packet));
 236   MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
 237   MOCK_METHOD2(SendConnectionCloseWithDetails, void(QuicErrorCode error,
 238                                                     const string& details));
 239   MOCK_METHOD2(SendRstStream, void(QuicStreamId id,
 240                                    QuicRstStreamErrorCode error));
 241   MOCK_METHOD3(SendGoAway, void(QuicErrorCode error,
 242                                 QuicStreamId last_good_stream_id,
 243                                 const string& reason));
 244   MOCK_METHOD0(OnCanWrite, bool());
 245   MOCK_CONST_METHOD0(HasPendingHandshake, bool());
 246
 247   void ProcessUdpPacketInternal(const IPEndPoint& self_address,
 248                                 const IPEndPoint& peer_address,
 249                                 const QuicEncryptedPacket& packet) {
 250     QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
 251   }
 252
 253   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
 254     return false;
 255   }
 256
 257  private:
 258   const bool has_mock_helper_;
 259   scoped_ptr<QuicPacketWriter> writer_;
 260   scoped_ptr<QuicConnectionHelperInterface> helper_;
 261
 262   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 263 };
 264
 265 class PacketSavingConnection : public MockConnection {
 266  public:
 267   PacketSavingConnection(QuicGuid guid, IPEndPoint address, bool is_server);
 268   virtual ~PacketSavingConnection();
 269
 270   virtual bool SendOrQueuePacket(
 271       EncryptionLevel level,
 272       QuicPacketSequenceNumber sequence_number,
 273       QuicPacket* packet,
 274       QuicPacketEntropyHash entropy_hash,
 275       TransmissionType transmission_type,
 276       HasRetransmittableData has_retransmittable_data,
 277       IsHandshake handshake,
 278       Force forced) OVERRIDE;
 279
 280   std::vector<QuicPacket*> packets_;
 281   std::vector<QuicEncryptedPacket*> encrypted_packets_;
 282
 283  private:
 284   DISALLOW_COPY_AND_ASSIGN(PacketSavingConnection);
 285 };
 286
 287 class MockSession : public QuicSession {
 288  public:
 289   MockSession(QuicConnection* connection, bool is_server);
 290   virtual ~MockSession();
 291
 292   MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
 293                               const IPEndPoint& peer_address,
 294                               const QuicPacketHeader& header,
 295                               const std::vector<QuicStreamFrame>& frame));
 296   MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer));
 297   MOCK_METHOD1(CreateIncomingReliableStream,
 298                ReliableQuicStream*(QuicStreamId id));
 299   MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*());
 300   MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
 301   MOCK_METHOD5(WritevData, QuicConsumedData(QuicStreamId id,
 302                                             const struct iovec* iov,
 303                                             int count,
 304                                             QuicStreamOffset offset,
 305                                             bool fin));
 306   MOCK_METHOD0(IsHandshakeComplete, bool());
 307   MOCK_METHOD0(IsCryptoHandshakeConfirmed, bool());
 308
 309  private:
 310   DISALLOW_COPY_AND_ASSIGN(MockSession);
 311 };
 312
 313 class TestSession : public QuicSession {
 314  public:
 315   TestSession(QuicConnection* connection,
 316               const QuicConfig& config,
 317               bool is_server);
 318   virtual ~TestSession();
 319
 320   MOCK_METHOD1(CreateIncomingReliableStream,
 321                ReliableQuicStream*(QuicStreamId id));
 322   MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
 323
 324   void SetCryptoStream(QuicCryptoStream* stream);
 325
 326   virtual QuicCryptoStream* GetCryptoStream();
 327
 328  private:
 329   QuicCryptoStream* crypto_stream_;
 330   DISALLOW_COPY_AND_ASSIGN(TestSession);
 331 };
 332
 333 class MockPacketWriter : public QuicPacketWriter {
 334  public:
 335   MockPacketWriter();
 336   virtual ~MockPacketWriter();
 337
 338   MOCK_METHOD5(WritePacket,
 339                WriteResult(const char* buffer,
 340                            size_t buf_len,
 341                            const IPAddressNumber& self_address,
 342                            const IPEndPoint& peer_address,
 343                            QuicBlockedWriterInterface* blocked_writer));
 344   MOCK_CONST_METHOD0(IsWriteBlockedDataBuffered, bool());
 345 };
 346
 347 class MockSendAlgorithm : public SendAlgorithmInterface {
 348  public:
 349   MockSendAlgorithm();
 350   virtual ~MockSendAlgorithm();
 351
 352   MOCK_METHOD2(SetFromConfig, void(const QuicConfig& config, bool is_server));
 353   MOCK_METHOD3(OnIncomingQuicCongestionFeedbackFrame,
 354                void(const QuicCongestionFeedbackFrame&,
 355                     QuicTime feedback_receive_time,
 356                     const SentPacketsMap&));
 357   MOCK_METHOD3(OnIncomingAck,
 358                void(QuicPacketSequenceNumber, QuicByteCount, QuicTime::Delta));
 359   MOCK_METHOD1(OnIncomingLoss, void(QuicTime));
 360   MOCK_METHOD5(OnPacketSent,
 361                bool(QuicTime sent_time, QuicPacketSequenceNumber, QuicByteCount,
 362                     TransmissionType, HasRetransmittableData));
 363   MOCK_METHOD2(OnPacketAbandoned, void(QuicPacketSequenceNumber sequence_number,
 364                                       QuicByteCount abandoned_bytes));
 365   MOCK_METHOD4(TimeUntilSend, QuicTime::Delta(QuicTime now, TransmissionType,
 366                                               HasRetransmittableData,
 367                                               IsHandshake));
 368   MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
 369   MOCK_METHOD0(SmoothedRtt, QuicTime::Delta(void));
 370   MOCK_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
 371   MOCK_METHOD0(GetCongestionWindow, QuicByteCount());
 372   MOCK_METHOD1(SetCongestionWindow, void(QuicByteCount));
 373
 374  private:
 375   DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm);
 376 };
 377
 378 class TestEntropyCalculator :
 379       public QuicReceivedEntropyHashCalculatorInterface {
 380  public:
 381   TestEntropyCalculator();
 382   virtual ~TestEntropyCalculator();
 383
 384   virtual QuicPacketEntropyHash EntropyHash(
 385       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
 386 };
 387
 388 class MockEntropyCalculator : public TestEntropyCalculator {
 389  public:
 390   MockEntropyCalculator();
 391   virtual ~MockEntropyCalculator();
 392
 393   MOCK_CONST_METHOD1(
 394       EntropyHash,
 395       QuicPacketEntropyHash(QuicPacketSequenceNumber sequence_number));
 396 };
 397
 398 class TestDecompressorVisitor : public QuicSpdyDecompressor::Visitor {
 399  public:
 400   virtual ~TestDecompressorVisitor() {}
 401   virtual bool OnDecompressedData(base::StringPiece data) OVERRIDE;
 402   virtual void OnDecompressionError() OVERRIDE;
 403
 404   string data() { return data_; }
 405   bool error() { return error_; }
 406
 407  private:
 408   string data_;
 409   bool error_;
 410 };
 411
 412 class MockAckNotifierDelegate : public QuicAckNotifier::DelegateInterface {
 413  public:
 414   MockAckNotifierDelegate();
 415   virtual ~MockAckNotifierDelegate();
 416
 417   MOCK_METHOD0(OnAckNotification, void());
 418 };
 419
 420 }  // namespace test
 421 }  // namespace net
 422
 423 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_