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