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 // 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 void CompareCharArraysWithHexError(const std::string& description,
     29                                    const char* actual,
     30                                    const int actual_len,
     31                                    const char* expected,
     32                                    const int expected_len);
     33 
     34 void CompareQuicDataWithHexError(const std::string& description,
     35                                  QuicData* actual,
     36                                  QuicData* expected);
     37 
     38 // Returns the length of a QuicPacket that is capable of holding either a
     39 // stream frame or a minimal ack frame.  Sets |*payload_length| to the number
     40 // of bytes of stream data that will fit in such a packet.
     41 size_t GetPacketLengthForOneStream(QuicVersion version,
     42                                    bool include_version,
     43                                    InFecGroup is_in_fec_group,
     44                                    size_t* payload_length);
     45 
     46 // Size in bytes of the stream frame fields for an arbitrary StreamID and
     47 // offset and the last frame in a packet.
     48 size_t GetMinStreamFrameSize(QuicVersion version);
     49 
     50 string SerializeUncompressedHeaders(const SpdyHeaderBlock& headers);
     51 
     52 // Returns QuicConfig set to default values.
     53 QuicConfig DefaultQuicConfig();
     54 
     55 class MockFramerVisitor : public QuicFramerVisitorInterface {
     56  public:
     57   MockFramerVisitor();
     58   ~MockFramerVisitor();
     59 
     60   MOCK_METHOD1(OnError, void(QuicFramer* framer));
     61   // The constructor sets this up to return false by default.
     62   MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicVersion version));
     63   MOCK_METHOD0(OnPacket, void());
     64   MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
     65   MOCK_METHOD1(OnVersionNegotiationPacket,
     66                void(const QuicVersionNegotiationPacket& packet));
     67   MOCK_METHOD0(OnRevivedPacket, void());
     68   // The constructor sets this up to return true by default.
     69   MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
     70   MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload));
     71   MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
     72   MOCK_METHOD1(OnAckFrame, bool(const QuicAckFrame& frame));
     73   MOCK_METHOD1(OnCongestionFeedbackFrame,
     74                bool(const QuicCongestionFeedbackFrame& frame));
     75   MOCK_METHOD1(OnFecData, void(const QuicFecData& fec));
     76   MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame));
     77   MOCK_METHOD1(OnConnectionCloseFrame,
     78                bool(const QuicConnectionCloseFrame& frame));
     79   MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame));
     80   MOCK_METHOD0(OnPacketComplete, void());
     81 
     82  private:
     83   DISALLOW_COPY_AND_ASSIGN(MockFramerVisitor);
     84 };
     85 
     86 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
     87  public:
     88   NoOpFramerVisitor() {}
     89 
     90   virtual void OnError(QuicFramer* framer) OVERRIDE {}
     91   virtual void OnPacket() OVERRIDE {}
     92   virtual void OnPublicResetPacket(
     93       const QuicPublicResetPacket& packet) OVERRIDE {}
     94   virtual void OnVersionNegotiationPacket(
     95       const QuicVersionNegotiationPacket& packet) OVERRIDE {}
     96   virtual void OnRevivedPacket() OVERRIDE {}
     97   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
     98   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
     99   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
    100   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
    101   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
    102   virtual bool OnCongestionFeedbackFrame(
    103       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
    104   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
    105   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
    106   virtual bool OnConnectionCloseFrame(
    107       const QuicConnectionCloseFrame& frame) OVERRIDE;
    108   virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
    109   virtual void OnPacketComplete() OVERRIDE {}
    110 
    111  private:
    112   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
    113 };
    114 
    115 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
    116  public:
    117   FramerVisitorCapturingPublicReset();
    118   virtual ~FramerVisitorCapturingPublicReset();
    119 
    120   virtual void OnPublicResetPacket(
    121       const QuicPublicResetPacket& packet) OVERRIDE;
    122 
    123   const QuicPublicResetPacket public_reset_packet() {
    124     return public_reset_packet_;
    125   }
    126 
    127  private:
    128   QuicPublicResetPacket public_reset_packet_;
    129 };
    130 
    131 class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
    132  public:
    133   FramerVisitorCapturingFrames();
    134   virtual ~FramerVisitorCapturingFrames();
    135 
    136   // NoOpFramerVisitor
    137   virtual void OnVersionNegotiationPacket(
    138       const QuicVersionNegotiationPacket& packet) OVERRIDE;
    139   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
    140   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
    141   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
    142   virtual bool OnCongestionFeedbackFrame(
    143       const QuicCongestionFeedbackFrame& frame) 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 
    149   size_t frame_count() const { return frame_count_; }
    150   QuicPacketHeader* header() { return &header_; }
    151   const std::vector<QuicStreamFrame>* stream_frames() const {
    152     return &stream_frames_;
    153   }
    154   QuicAckFrame* ack() { return ack_.get(); }
    155   QuicCongestionFeedbackFrame* feedback() { return feedback_.get(); }
    156   QuicRstStreamFrame* rst() { return rst_.get(); }
    157   QuicConnectionCloseFrame* close() { return close_.get(); }
    158   QuicGoAwayFrame* goaway() { return goaway_.get(); }
    159   QuicVersionNegotiationPacket* version_negotiation_packet() {
    160     return version_negotiation_packet_.get();
    161   }
    162 
    163  private:
    164   size_t frame_count_;
    165   QuicPacketHeader header_;
    166   std::vector<QuicStreamFrame> stream_frames_;
    167   scoped_ptr<QuicAckFrame> ack_;
    168   scoped_ptr<QuicCongestionFeedbackFrame> feedback_;
    169   scoped_ptr<QuicRstStreamFrame> rst_;
    170   scoped_ptr<QuicConnectionCloseFrame> close_;
    171   scoped_ptr<QuicGoAwayFrame> goaway_;
    172   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
    173 
    174   DISALLOW_COPY_AND_ASSIGN(FramerVisitorCapturingFrames);
    175 };
    176 
    177 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
    178  public:
    179   MockConnectionVisitor();
    180   virtual ~MockConnectionVisitor();
    181 
    182   MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
    183                               const IPEndPoint& peer_address,
    184                               const QuicPacketHeader& header,
    185                               const std::vector<QuicStreamFrame>& frame));
    186   MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
    187   MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
    188   MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
    189   MOCK_METHOD1(OnAck, void(const SequenceNumberSet& acked_packets));
    190   MOCK_METHOD0(OnCanWrite, bool());
    191 
    192  private:
    193   DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor);
    194 };
    195 
    196 class MockHelper : public QuicConnectionHelperInterface {
    197  public:
    198   MockHelper();
    199   virtual ~MockHelper();
    200 
    201   MOCK_METHOD1(SetConnection, void(QuicConnection* connection));
    202   const QuicClock* GetClock() const;
    203   QuicRandom* GetRandomGenerator();
    204   void AdvanceTime(QuicTime::Delta delta);
    205   MOCK_METHOD2(WritePacketToWire, int(const QuicEncryptedPacket& packet,
    206                                       int* error));
    207   MOCK_METHOD0(IsWriteBlockedDataBuffered, bool());
    208   MOCK_METHOD1(IsWriteBlocked, bool(int));
    209   virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate);
    210 
    211  private:
    212   MockClock clock_;
    213   MockRandom random_generator_;
    214 };
    215 
    216 class MockConnection : public QuicConnection {
    217  public:
    218   // Uses a MockHelper.
    219   MockConnection(QuicGuid guid, IPEndPoint address, bool is_server);
    220   MockConnection(QuicGuid guid,
    221                  IPEndPoint address,
    222                  QuicConnectionHelperInterface* helper,
    223                  bool is_server);
    224   virtual ~MockConnection();
    225 
    226   // If the constructor that uses a MockHelper has been used then this method
    227   // will advance the time of the MockClock.
    228   void AdvanceTime(QuicTime::Delta delta);
    229 
    230   MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
    231                                       const IPEndPoint& peer_address,
    232                                       const QuicEncryptedPacket& packet));
    233   MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
    234   MOCK_METHOD2(SendConnectionCloseWithDetails, void(QuicErrorCode error,
    235                                                     const string& details));
    236   MOCK_METHOD2(SendRstStream, void(QuicStreamId id,
    237                                    QuicRstStreamErrorCode error));
    238   MOCK_METHOD3(SendGoAway, void(QuicErrorCode error,
    239                                 QuicStreamId last_good_stream_id,
    240                                 const string& reason));
    241   MOCK_METHOD0(OnCanWrite, bool());
    242 
    243   void ProcessUdpPacketInternal(const IPEndPoint& self_address,
    244                                 const IPEndPoint& peer_address,
    245                                 const QuicEncryptedPacket& packet) {
    246     QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
    247   }
    248 
    249   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
    250     return false;
    251   }
    252 
    253  private:
    254   const bool has_mock_helper_;
    255 
    256   DISALLOW_COPY_AND_ASSIGN(MockConnection);
    257 };
    258 
    259 class PacketSavingConnection : public MockConnection {
    260  public:
    261   PacketSavingConnection(QuicGuid guid, IPEndPoint address, bool is_server);
    262   virtual ~PacketSavingConnection();
    263 
    264   virtual bool SendOrQueuePacket(
    265       EncryptionLevel level,
    266       QuicPacketSequenceNumber sequence_number,
    267       QuicPacket* packet,
    268       QuicPacketEntropyHash entropy_hash,
    269       HasRetransmittableData has_retransmittable_data) OVERRIDE;
    270 
    271   std::vector<QuicPacket*> packets_;
    272   std::vector<QuicEncryptedPacket*> encrypted_packets_;
    273 
    274  private:
    275   DISALLOW_COPY_AND_ASSIGN(PacketSavingConnection);
    276 };
    277 
    278 class MockSession : public QuicSession {
    279  public:
    280   MockSession(QuicConnection* connection, bool is_server);
    281   virtual ~MockSession();
    282 
    283   MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
    284                               const IPEndPoint& peer_address,
    285                               const QuicPacketHeader& header,
    286                               const std::vector<QuicStreamFrame>& frame));
    287   MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
    288   MOCK_METHOD1(CreateIncomingReliableStream,
    289                ReliableQuicStream*(QuicStreamId id));
    290   MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*());
    291   MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
    292   MOCK_METHOD4(WriteData, QuicConsumedData(QuicStreamId id,
    293                                            base::StringPiece data,
    294                                            QuicStreamOffset offset,
    295                                            bool fin));
    296   MOCK_METHOD0(IsHandshakeComplete, bool());
    297 
    298  private:
    299   DISALLOW_COPY_AND_ASSIGN(MockSession);
    300 };
    301 
    302 class TestSession : public QuicSession {
    303  public:
    304   TestSession(QuicConnection* connection,
    305               const QuicConfig& config,
    306               bool is_server);
    307   virtual ~TestSession();
    308 
    309   MOCK_METHOD1(CreateIncomingReliableStream,
    310                ReliableQuicStream*(QuicStreamId id));
    311   MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
    312 
    313   void SetCryptoStream(QuicCryptoStream* stream);
    314 
    315   virtual QuicCryptoStream* GetCryptoStream();
    316 
    317  private:
    318   QuicCryptoStream* crypto_stream_;
    319   DISALLOW_COPY_AND_ASSIGN(TestSession);
    320 };
    321 
    322 class MockSendAlgorithm : public SendAlgorithmInterface {
    323  public:
    324   MockSendAlgorithm();
    325   virtual ~MockSendAlgorithm();
    326 
    327   MOCK_METHOD3(OnIncomingQuicCongestionFeedbackFrame,
    328                void(const QuicCongestionFeedbackFrame&,
    329                     QuicTime feedback_receive_time,
    330                     const SentPacketsMap&));
    331   MOCK_METHOD3(OnIncomingAck,
    332                void(QuicPacketSequenceNumber, QuicByteCount, QuicTime::Delta));
    333   MOCK_METHOD1(OnIncomingLoss, void(QuicTime));
    334   MOCK_METHOD4(SentPacket, void(QuicTime sent_time, QuicPacketSequenceNumber,
    335                                 QuicByteCount, Retransmission));
    336   MOCK_METHOD2(AbandoningPacket, void(QuicPacketSequenceNumber sequence_number,
    337                                       QuicByteCount abandoned_bytes));
    338   MOCK_METHOD4(TimeUntilSend, QuicTime::Delta(QuicTime now, Retransmission,
    339                                               HasRetransmittableData,
    340                                               IsHandshake));
    341   MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
    342   MOCK_METHOD0(SmoothedRtt, QuicTime::Delta(void));
    343   MOCK_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
    344 
    345  private:
    346   DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm);
    347 };
    348 
    349 class TestEntropyCalculator :
    350       public QuicReceivedEntropyHashCalculatorInterface {
    351  public:
    352   TestEntropyCalculator() { }
    353   virtual ~TestEntropyCalculator() { }
    354 
    355   virtual QuicPacketEntropyHash EntropyHash(
    356       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
    357 };
    358 
    359 class TestDecompressorVisitor : public QuicSpdyDecompressor::Visitor {
    360  public:
    361   virtual ~TestDecompressorVisitor() {}
    362   virtual bool OnDecompressedData(base::StringPiece data) OVERRIDE;
    363   virtual void OnDecompressionError() OVERRIDE;
    364 
    365   string data() { return data_; }
    366   bool error() { return error_; }
    367 
    368  private:
    369   string data_;
    370   bool error_;
    371 };
    372 
    373 }  // namespace test
    374 }  // namespace net
    375 
    376 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
    377