| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Common utilities for Quic tests |
| |
| #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ |
| #define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ |
| |
| #include <cstdint> |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "net/third_party/quiche/src/quic/core/congestion_control/loss_detection_interface.h" |
| #include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h" |
| #include "net/third_party/quiche/src/quic/core/http/quic_client_push_promise_index.h" |
| #include "net/third_party/quiche/src/quic/core/http/quic_server_session_base.h" |
| #include "net/third_party/quiche/src/quic/core/quic_connection.h" |
| #include "net/third_party/quiche/src/quic/core/quic_framer.h" |
| #include "net/third_party/quiche/src/quic/core/quic_packet_writer.h" |
| #include "net/third_party/quiche/src/quic/core/quic_sent_packet_manager.h" |
| #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" |
| #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h" |
| #include "net/third_party/quiche/src/quic/test_tools/mock_quic_session_visitor.h" |
| #include "net/third_party/quiche/src/quic/test_tools/mock_random.h" |
| |
| namespace quic { |
| |
| namespace test { |
| |
| // A generic predictable connection ID suited for testing. |
| QuicConnectionId TestConnectionId(); |
| |
| // A generic predictable connection ID suited for testing, generated from a |
| // given number, such as an index. |
| QuicConnectionId TestConnectionId(uint64_t connection_number); |
| |
| // A generic predictable connection ID suited for testing, generated from a |
| // given number, such as an index. Guaranteed to be 9 bytes long. |
| QuicConnectionId TestConnectionIdNineBytesLong(uint64_t connection_number); |
| |
| // Extracts the connection number passed to TestConnectionId(). |
| uint64_t TestConnectionIdToUInt64(QuicConnectionId connection_id); |
| |
| static const uint16_t kTestPort = 12345; |
| static const uint32_t kInitialStreamFlowControlWindowForTest = |
| 1024 * 1024; // 1 MB |
| static const uint32_t kInitialSessionFlowControlWindowForTest = |
| 1536 * 1024; // 1.5 MB |
| |
| // Returns the test peer IP address. |
| QuicIpAddress TestPeerIPAddress(); |
| |
| // Upper limit on versions we support. |
| ParsedQuicVersion QuicVersionMax(); |
| |
| // Lower limit on versions we support. |
| ParsedQuicVersion QuicVersionMin(); |
| |
| // Upper limit on versions we support. |
| // TODO(nharper): Remove this function when it is no longer used. |
| QuicTransportVersion QuicTransportVersionMax(); |
| |
| // Lower limit on versions we support. |
| // TODO(nharper): Remove this function when it is no longer used. |
| QuicTransportVersion QuicTransportVersionMin(); |
| |
| // Create an encrypted packet for testing. |
| // If versions == nullptr, uses &AllSupportedVersions(). |
| // Note that the packet is encrypted with NullEncrypter, so to decrypt the |
| // constructed packet, the framer must be set to use NullDecrypter. |
| QuicEncryptedPacket* ConstructEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data, |
| bool full_padding, |
| QuicConnectionIdIncluded destination_connection_id_included, |
| QuicConnectionIdIncluded source_connection_id_included, |
| QuicPacketNumberLength packet_number_length, |
| ParsedQuicVersionVector* versions, |
| Perspective perspective); |
| |
| QuicEncryptedPacket* ConstructEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data, |
| bool full_padding, |
| QuicConnectionIdIncluded destination_connection_id_included, |
| QuicConnectionIdIncluded source_connection_id_included, |
| QuicPacketNumberLength packet_number_length, |
| ParsedQuicVersionVector* versions); |
| |
| // Create an encrypted packet for testing. |
| // If versions == nullptr, uses &AllSupportedVersions(). |
| // Note that the packet is encrypted with NullEncrypter, so to decrypt the |
| // constructed packet, the framer must be set to use NullDecrypter. |
| QuicEncryptedPacket* ConstructEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data, |
| QuicConnectionIdIncluded destination_connection_id_included, |
| QuicConnectionIdIncluded source_connection_id_included, |
| QuicPacketNumberLength packet_number_length, |
| ParsedQuicVersionVector* versions); |
| |
| // This form assumes |versions| == nullptr. |
| QuicEncryptedPacket* ConstructEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data, |
| QuicConnectionIdIncluded destination_connection_id_included, |
| QuicConnectionIdIncluded source_connection_id_included, |
| QuicPacketNumberLength packet_number_length); |
| |
| // This form assumes |connection_id_length| == PACKET_8BYTE_CONNECTION_ID, |
| // |packet_number_length| == PACKET_4BYTE_PACKET_NUMBER and |
| // |versions| == nullptr. |
| QuicEncryptedPacket* ConstructEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data); |
| |
| // Constructs a received packet for testing. The caller must take ownership of |
| // the returned pointer. |
| QuicReceivedPacket* ConstructReceivedPacket( |
| const QuicEncryptedPacket& encrypted_packet, |
| QuicTime receipt_time); |
| |
| // Create an encrypted packet for testing whose data portion erroneous. |
| // The specific way the data portion is erroneous is not specified, but |
| // it is an error that QuicFramer detects. |
| // Note that the packet is encrypted with NullEncrypter, so to decrypt the |
| // constructed packet, the framer must be set to use NullDecrypter. |
| QuicEncryptedPacket* ConstructMisFramedEncryptedPacket( |
| QuicConnectionId destination_connection_id, |
| QuicConnectionId source_connection_id, |
| bool version_flag, |
| bool reset_flag, |
| uint64_t packet_number, |
| const std::string& data, |
| QuicConnectionIdIncluded destination_connection_id_included, |
| QuicConnectionIdIncluded source_connection_id_included, |
| QuicPacketNumberLength packet_number_length, |
| ParsedQuicVersionVector* versions, |
| Perspective perspective); |
| |
| void CompareCharArraysWithHexError(const std::string& description, |
| const char* actual, |
| const int actual_len, |
| const char* expected, |
| const int expected_len); |
| |
| // Returns QuicConfig set to default values. |
| QuicConfig DefaultQuicConfig(); |
| |
| // Returns a version vector consisting of |version|. |
| QuicTransportVersionVector SupportedTransportVersions( |
| QuicTransportVersion version); |
| |
| ParsedQuicVersionVector SupportedVersions(ParsedQuicVersion version); |
| |
| struct QuicAckBlock { |
| QuicPacketNumber start; // Included |
| QuicPacketNumber limit; // Excluded |
| }; |
| |
| // Testing convenience method to construct a QuicAckFrame with arbitrary ack |
| // blocks. Each block is given by a (closed-open) range of packet numbers. e.g.: |
| // InitAckFrame({{1, 10}}) |
| // => 1 ack block acking packet numbers 1 to 9. |
| // |
| // InitAckFrame({{1, 2}, {3, 4}}) |
| // => 2 ack blocks acking packet 1 and 3. Packet 2 is missing. |
| QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks); |
| |
| // Testing convenience method to construct a QuicAckFrame with 1 ack block which |
| // covers packet number range [1, |largest_acked| + 1). |
| // Equivalent to InitAckFrame({{1, largest_acked + 1}}) |
| QuicAckFrame InitAckFrame(uint64_t largest_acked); |
| QuicAckFrame InitAckFrame(QuicPacketNumber largest_acked); |
| |
| // Testing convenience method to construct a QuicAckFrame with |num_ack_blocks| |
| // ack blocks of width 1 packet, starting from |least_unacked| + 2. |
| QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks, |
| uint64_t least_unacked); |
| |
| // Returns the encryption level that corresponds to the header type in |
| // |header|. If the header is for GOOGLE_QUIC_PACKET instead of an |
| // IETF-invariants packet, this function returns ENCRYPTION_INITIAL. |
| EncryptionLevel HeaderToEncryptionLevel(const QuicPacketHeader& header); |
| |
| // Returns a QuicPacket that is owned by the caller, and |
| // is populated with the fields in |header| and |frames|, or is nullptr if the |
| // packet could not be created. |
| std::unique_ptr<QuicPacket> BuildUnsizedDataPacket( |
| QuicFramer* framer, |
| const QuicPacketHeader& header, |
| const QuicFrames& frames); |
| // Returns a QuicPacket that is owned by the caller, and of size |packet_size|. |
| std::unique_ptr<QuicPacket> BuildUnsizedDataPacket( |
| QuicFramer* framer, |
| const QuicPacketHeader& header, |
| const QuicFrames& frames, |
| size_t packet_size); |
| |
| // Compute SHA-1 hash of the supplied std::string. |
| std::string Sha1Hash(QuicStringPiece data); |
| |
| // Delete |frame| and return true. |
| bool ClearControlFrame(const QuicFrame& frame); |
| |
| // Simple random number generator used to compute random numbers suitable |
| // for pseudo-randomly dropping packets in tests. |
| class SimpleRandom : public QuicRandom { |
| public: |
| SimpleRandom() { set_seed(0); } |
| SimpleRandom(const SimpleRandom&) = delete; |
| SimpleRandom& operator=(const SimpleRandom&) = delete; |
| ~SimpleRandom() override {} |
| |
| // Returns a random number in the range [0, kuint64max]. |
| uint64_t RandUint64() override; |
| |
| void RandBytes(void* data, size_t len) override; |
| |
| void set_seed(uint64_t seed); |
| |
| private: |
| uint8_t buffer_[4096]; |
| size_t buffer_offset_; |
| uint8_t key_[32]; |
| |
| void FillBuffer(); |
| }; |
| |
| class MockFramerVisitor : public QuicFramerVisitorInterface { |
| public: |
| MockFramerVisitor(); |
| MockFramerVisitor(const MockFramerVisitor&) = delete; |
| MockFramerVisitor& operator=(const MockFramerVisitor&) = delete; |
| ~MockFramerVisitor() override; |
| |
| MOCK_METHOD1(OnError, void(QuicFramer* framer)); |
| // The constructor sets this up to return false by default. |
| MOCK_METHOD1(OnProtocolVersionMismatch, bool(ParsedQuicVersion version)); |
| MOCK_METHOD0(OnPacket, void()); |
| MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header)); |
| MOCK_METHOD1(OnVersionNegotiationPacket, |
| void(const QuicVersionNegotiationPacket& packet)); |
| MOCK_METHOD3(OnRetryPacket, |
| void(QuicConnectionId original_connection_id, |
| QuicConnectionId new_connection_id, |
| QuicStringPiece retry_token)); |
| // The constructor sets this up to return true by default. |
| MOCK_METHOD1(OnUnauthenticatedHeader, bool(const QuicPacketHeader& header)); |
| // The constructor sets this up to return true by default. |
| MOCK_METHOD1(OnUnauthenticatedPublicHeader, |
| bool(const QuicPacketHeader& header)); |
| MOCK_METHOD1(OnDecryptedPacket, void(EncryptionLevel level)); |
| MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header)); |
| MOCK_METHOD1(OnCoalescedPacket, void(const QuicEncryptedPacket& packet)); |
| MOCK_METHOD3(OnUndecryptablePacket, |
| void(const QuicEncryptedPacket& packet, |
| EncryptionLevel decryption_level, |
| bool has_decryption_key)); |
| MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame)); |
| MOCK_METHOD1(OnCryptoFrame, bool(const QuicCryptoFrame& frame)); |
| MOCK_METHOD2(OnAckFrameStart, bool(QuicPacketNumber, QuicTime::Delta)); |
| MOCK_METHOD2(OnAckRange, bool(QuicPacketNumber, QuicPacketNumber)); |
| MOCK_METHOD2(OnAckTimestamp, bool(QuicPacketNumber, QuicTime)); |
| MOCK_METHOD1(OnAckFrameEnd, bool(QuicPacketNumber)); |
| MOCK_METHOD1(OnStopWaitingFrame, bool(const QuicStopWaitingFrame& frame)); |
| MOCK_METHOD1(OnPaddingFrame, bool(const QuicPaddingFrame& frame)); |
| MOCK_METHOD1(OnPingFrame, bool(const QuicPingFrame& frame)); |
| MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame)); |
| MOCK_METHOD1(OnConnectionCloseFrame, |
| bool(const QuicConnectionCloseFrame& frame)); |
| MOCK_METHOD1(OnNewConnectionIdFrame, |
| bool(const QuicNewConnectionIdFrame& frame)); |
| MOCK_METHOD1(OnRetireConnectionIdFrame, |
| bool(const QuicRetireConnectionIdFrame& frame)); |
| MOCK_METHOD1(OnNewTokenFrame, bool(const QuicNewTokenFrame& frame)); |
| MOCK_METHOD1(OnStopSendingFrame, bool(const QuicStopSendingFrame& frame)); |
| MOCK_METHOD1(OnPathChallengeFrame, bool(const QuicPathChallengeFrame& frame)); |
| MOCK_METHOD1(OnPathResponseFrame, bool(const QuicPathResponseFrame& frame)); |
| MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame)); |
| MOCK_METHOD1(OnMaxStreamsFrame, bool(const QuicMaxStreamsFrame& frame)); |
| MOCK_METHOD1(OnStreamsBlockedFrame, |
| bool(const QuicStreamsBlockedFrame& frame)); |
| MOCK_METHOD1(OnWindowUpdateFrame, bool(const QuicWindowUpdateFrame& frame)); |
| MOCK_METHOD1(OnBlockedFrame, bool(const QuicBlockedFrame& frame)); |
| MOCK_METHOD1(OnMessageFrame, bool(const QuicMessageFrame& frame)); |
| MOCK_METHOD0(OnPacketComplete, void()); |
| MOCK_CONST_METHOD1(IsValidStatelessResetToken, bool(QuicUint128)); |
| MOCK_METHOD1(OnAuthenticatedIetfStatelessResetPacket, |
| void(const QuicIetfStatelessResetPacket&)); |
| }; |
| |
| class NoOpFramerVisitor : public QuicFramerVisitorInterface { |
| public: |
| NoOpFramerVisitor() {} |
| NoOpFramerVisitor(const NoOpFramerVisitor&) = delete; |
| NoOpFramerVisitor& operator=(const NoOpFramerVisitor&) = delete; |
| |
| void OnError(QuicFramer* /*framer*/) override {} |
| void OnPacket() override {} |
| void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {} |
| void OnVersionNegotiationPacket( |
| const QuicVersionNegotiationPacket& /*packet*/) override {} |
| void OnRetryPacket(QuicConnectionId /*original_connection_id*/, |
| QuicConnectionId /*new_connection_id*/, |
| QuicStringPiece /*retry_token*/) override {} |
| bool OnProtocolVersionMismatch(ParsedQuicVersion version) override; |
| bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override; |
| bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override; |
| void OnDecryptedPacket(EncryptionLevel /*level*/) override {} |
| bool OnPacketHeader(const QuicPacketHeader& header) override; |
| void OnCoalescedPacket(const QuicEncryptedPacket& packet) override; |
| void OnUndecryptablePacket(const QuicEncryptedPacket& packet, |
| EncryptionLevel decryption_level, |
| bool has_decryption_key) override; |
| bool OnStreamFrame(const QuicStreamFrame& frame) override; |
| bool OnCryptoFrame(const QuicCryptoFrame& frame) override; |
| bool OnAckFrameStart(QuicPacketNumber largest_acked, |
| QuicTime::Delta ack_delay_time) override; |
| bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override; |
| bool OnAckTimestamp(QuicPacketNumber packet_number, |
| QuicTime timestamp) override; |
| bool OnAckFrameEnd(QuicPacketNumber start) override; |
| bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override; |
| bool OnPaddingFrame(const QuicPaddingFrame& frame) override; |
| bool OnPingFrame(const QuicPingFrame& frame) override; |
| bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override; |
| bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override; |
| bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override; |
| bool OnRetireConnectionIdFrame( |
| const QuicRetireConnectionIdFrame& frame) override; |
| bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override; |
| bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override; |
| bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override; |
| bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override; |
| bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override; |
| bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override; |
| bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override; |
| bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override; |
| bool OnBlockedFrame(const QuicBlockedFrame& frame) override; |
| bool OnMessageFrame(const QuicMessageFrame& frame) override; |
| void OnPacketComplete() override {} |
| bool IsValidStatelessResetToken(QuicUint128 token) const override; |
| void OnAuthenticatedIetfStatelessResetPacket( |
| const QuicIetfStatelessResetPacket& /*packet*/) override {} |
| }; |
| |
| class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface { |
| public: |
| MockQuicConnectionVisitor(); |
| MockQuicConnectionVisitor(const MockQuicConnectionVisitor&) = delete; |
| MockQuicConnectionVisitor& operator=(const MockQuicConnectionVisitor&) = |
| delete; |
| ~MockQuicConnectionVisitor() override; |
| |
| MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame& frame)); |
| MOCK_METHOD1(OnCryptoFrame, void(const QuicCryptoFrame& frame)); |
| MOCK_METHOD1(OnWindowUpdateFrame, void(const QuicWindowUpdateFrame& frame)); |
| MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame& frame)); |
| MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame)); |
| MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame)); |
| MOCK_METHOD1(OnMessageReceived, void(QuicStringPiece message)); |
| MOCK_METHOD2(OnConnectionClosed, |
| void(const QuicConnectionCloseFrame& frame, |
| ConnectionCloseSource source)); |
| MOCK_METHOD0(OnWriteBlocked, void()); |
| MOCK_METHOD0(OnCanWrite, void()); |
| MOCK_METHOD0(SendProbingData, bool()); |
| MOCK_METHOD1(OnCongestionWindowChange, void(QuicTime now)); |
| MOCK_METHOD1(OnConnectionMigration, void(AddressChangeType type)); |
| MOCK_METHOD0(OnPathDegrading, void()); |
| MOCK_CONST_METHOD0(WillingAndAbleToWrite, bool()); |
| MOCK_CONST_METHOD0(HasPendingHandshake, bool()); |
| MOCK_CONST_METHOD0(ShouldKeepConnectionAlive, bool()); |
| MOCK_METHOD1(OnSuccessfulVersionNegotiation, |
| void(const ParsedQuicVersion& version)); |
| MOCK_METHOD3(OnPacketReceived, |
| void(const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| bool is_connectivity_probe)); |
| MOCK_METHOD0(OnConfigNegotiated, void()); |
| MOCK_METHOD0(OnAckNeedsRetransmittableFrame, void()); |
| MOCK_METHOD0(SendPing, void()); |
| MOCK_CONST_METHOD0(AllowSelfAddressChange, bool()); |
| MOCK_METHOD0(OnForwardProgressConfirmed, void()); |
| MOCK_METHOD1(OnMaxStreamsFrame, bool(const QuicMaxStreamsFrame& frame)); |
| MOCK_METHOD1(OnStreamsBlockedFrame, |
| bool(const QuicStreamsBlockedFrame& frame)); |
| MOCK_METHOD1(OnStopSendingFrame, void(const QuicStopSendingFrame& frame)); |
| }; |
| |
| class MockQuicConnectionHelper : public QuicConnectionHelperInterface { |
| public: |
| MockQuicConnectionHelper(); |
| MockQuicConnectionHelper(const MockQuicConnectionHelper&) = delete; |
| MockQuicConnectionHelper& operator=(const MockQuicConnectionHelper&) = delete; |
| ~MockQuicConnectionHelper() override; |
| const QuicClock* GetClock() const override; |
| QuicRandom* GetRandomGenerator() override; |
| QuicBufferAllocator* GetStreamSendBufferAllocator() override; |
| void AdvanceTime(QuicTime::Delta delta); |
| |
| private: |
| MockClock clock_; |
| MockRandom random_generator_; |
| SimpleBufferAllocator buffer_allocator_; |
| }; |
| |
| class MockAlarmFactory : public QuicAlarmFactory { |
| public: |
| QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override; |
| QuicArenaScopedPtr<QuicAlarm> CreateAlarm( |
| QuicArenaScopedPtr<QuicAlarm::Delegate> delegate, |
| QuicConnectionArena* arena) override; |
| |
| // No-op alarm implementation |
| class TestAlarm : public QuicAlarm { |
| public: |
| explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate) |
| : QuicAlarm(std::move(delegate)) {} |
| |
| void SetImpl() override {} |
| void CancelImpl() override {} |
| |
| using QuicAlarm::Fire; |
| }; |
| |
| void FireAlarm(QuicAlarm* alarm) { |
| reinterpret_cast<TestAlarm*>(alarm)->Fire(); |
| } |
| }; |
| |
| class MockQuicConnection : public QuicConnection { |
| public: |
| // Uses a ConnectionId of 42 and 127.0.0.1:123. |
| MockQuicConnection(MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective); |
| |
| // Uses a ConnectionId of 42. |
| MockQuicConnection(QuicSocketAddress address, |
| MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective); |
| |
| // Uses 127.0.0.1:123. |
| MockQuicConnection(QuicConnectionId connection_id, |
| MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective); |
| |
| // Uses a ConnectionId of 42, and 127.0.0.1:123. |
| MockQuicConnection(MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective, |
| const ParsedQuicVersionVector& supported_versions); |
| |
| MockQuicConnection(QuicConnectionId connection_id, |
| QuicSocketAddress address, |
| MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective, |
| const ParsedQuicVersionVector& supported_versions); |
| MockQuicConnection(const MockQuicConnection&) = delete; |
| MockQuicConnection& operator=(const MockQuicConnection&) = delete; |
| |
| ~MockQuicConnection() override; |
| |
| // If the constructor that uses a MockQuicConnectionHelper has been used then |
| // this method |
| // will advance the time of the MockClock. |
| void AdvanceTime(QuicTime::Delta delta); |
| |
| MOCK_METHOD3(ProcessUdpPacket, |
| void(const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| const QuicReceivedPacket& packet)); |
| MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error)); |
| MOCK_METHOD3(CloseConnection, |
| void(QuicErrorCode error, |
| const std::string& details, |
| ConnectionCloseBehavior connection_close_behavior)); |
| MOCK_METHOD2(SendConnectionClosePacket, |
| void(QuicErrorCode error, const std::string& details)); |
| MOCK_METHOD3(SendRstStream, |
| void(QuicStreamId id, |
| QuicRstStreamErrorCode error, |
| QuicStreamOffset bytes_written)); |
| MOCK_METHOD3(SendGoAway, |
| void(QuicErrorCode error, |
| QuicStreamId last_good_stream_id, |
| const std::string& reason)); |
| MOCK_METHOD1(SendBlocked, void(QuicStreamId id)); |
| MOCK_METHOD2(SendWindowUpdate, |
| void(QuicStreamId id, QuicStreamOffset byte_offset)); |
| MOCK_METHOD0(OnCanWrite, void()); |
| MOCK_METHOD1(SendConnectivityProbingResponsePacket, |
| void(const QuicSocketAddress& peer_address)); |
| MOCK_METHOD2(SendConnectivityProbingPacket, |
| bool(QuicPacketWriter* probing_writer, |
| const QuicSocketAddress& peer_address)); |
| |
| MOCK_METHOD1(OnSendConnectionState, void(const CachedNetworkParameters&)); |
| MOCK_METHOD2(ResumeConnectionState, |
| void(const CachedNetworkParameters&, bool)); |
| MOCK_METHOD1(SetMaxPacingRate, void(QuicBandwidth)); |
| |
| MOCK_METHOD2(OnStreamReset, void(QuicStreamId, QuicRstStreamErrorCode)); |
| MOCK_METHOD1(SendControlFrame, bool(const QuicFrame& frame)); |
| MOCK_METHOD2(SendMessage, MessageStatus(QuicMessageId, QuicMemSliceSpan)); |
| MOCK_METHOD3(OnConnectionClosed, |
| void(QuicErrorCode error, |
| const std::string& error_details, |
| ConnectionCloseSource source)); |
| |
| MOCK_METHOD1(OnError, void(QuicFramer* framer)); |
| void QuicConnection_OnError(QuicFramer* framer) { |
| QuicConnection::OnError(framer); |
| } |
| |
| void ReallyCloseConnection( |
| QuicErrorCode error, |
| const std::string& details, |
| ConnectionCloseBehavior connection_close_behavior) { |
| QuicConnection::CloseConnection(error, details, connection_close_behavior); |
| } |
| |
| void ReallyProcessUdpPacket(const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| const QuicReceivedPacket& packet) { |
| QuicConnection::ProcessUdpPacket(self_address, peer_address, packet); |
| } |
| |
| bool OnProtocolVersionMismatch(ParsedQuicVersion version) override; |
| |
| bool ReallySendControlFrame(const QuicFrame& frame) { |
| return QuicConnection::SendControlFrame(frame); |
| } |
| |
| bool ReallySendConnectivityProbingPacket( |
| QuicPacketWriter* probing_writer, |
| const QuicSocketAddress& peer_address) { |
| return QuicConnection::SendConnectivityProbingPacket(probing_writer, |
| peer_address); |
| } |
| |
| void ReallySendConnectivityProbingResponsePacket( |
| const QuicSocketAddress& peer_address) { |
| QuicConnection::SendConnectivityProbingResponsePacket(peer_address); |
| } |
| MOCK_METHOD1(OnPathResponseFrame, bool(const QuicPathResponseFrame&)); |
| MOCK_METHOD1(OnStopSendingFrame, bool(const QuicStopSendingFrame& frame)); |
| MOCK_METHOD3(SendCryptoData, |
| size_t(EncryptionLevel, size_t, QuicStreamOffset)); |
| size_t QuicConnection_SendCryptoData(EncryptionLevel level, |
| size_t write_length, |
| QuicStreamOffset offset) { |
| return QuicConnection::SendCryptoData(level, write_length, offset); |
| } |
| }; |
| |
| class PacketSavingConnection : public MockQuicConnection { |
| public: |
| PacketSavingConnection(MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective); |
| |
| PacketSavingConnection(MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| Perspective perspective, |
| const ParsedQuicVersionVector& supported_versions); |
| PacketSavingConnection(const PacketSavingConnection&) = delete; |
| PacketSavingConnection& operator=(const PacketSavingConnection&) = delete; |
| |
| ~PacketSavingConnection() override; |
| |
| void SendOrQueuePacket(SerializedPacket* packet) override; |
| |
| std::vector<std::unique_ptr<QuicEncryptedPacket>> encrypted_packets_; |
| MockClock clock_; |
| }; |
| |
| class MockQuicSession : public QuicSession { |
| public: |
| // Takes ownership of |connection|. |
| MockQuicSession(QuicConnection* connection, bool create_mock_crypto_stream); |
| |
| // Takes ownership of |connection|. |
| explicit MockQuicSession(QuicConnection* connection); |
| MockQuicSession(const MockQuicSession&) = delete; |
| MockQuicSession& operator=(const MockQuicSession&) = delete; |
| ~MockQuicSession() override; |
| |
| QuicCryptoStream* GetMutableCryptoStream() override; |
| const QuicCryptoStream* GetCryptoStream() const override; |
| void SetCryptoStream(QuicCryptoStream* crypto_stream); |
| |
| MOCK_METHOD2(OnConnectionClosed, |
| void(const QuicConnectionCloseFrame& frame, |
| ConnectionCloseSource source)); |
| MOCK_METHOD1(CreateIncomingStream, QuicStream*(QuicStreamId id)); |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream)); |
| MOCK_METHOD1(ShouldCreateIncomingStream2, bool(QuicStreamId id)); |
| MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool()); |
| MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool()); |
| MOCK_METHOD5(WritevData, |
| QuicConsumedData(QuicStream* stream, |
| QuicStreamId id, |
| size_t write_length, |
| QuicStreamOffset offset, |
| StreamSendingState state)); |
| |
| MOCK_METHOD3(SendRstStream, |
| void(QuicStreamId stream_id, |
| QuicRstStreamErrorCode error, |
| QuicStreamOffset bytes_written)); |
| |
| MOCK_METHOD2(OnStreamHeaders, |
| void(QuicStreamId stream_id, QuicStringPiece headers_data)); |
| MOCK_METHOD2(OnStreamHeadersPriority, |
| void(QuicStreamId stream_id, spdy::SpdyPriority priority)); |
| MOCK_METHOD3(OnStreamHeadersComplete, |
| void(QuicStreamId stream_id, bool fin, size_t frame_len)); |
| MOCK_CONST_METHOD0(ShouldKeepConnectionAlive, bool()); |
| MOCK_METHOD2(SendStopSending, void(uint16_t code, QuicStreamId stream_id)); |
| MOCK_METHOD1(OnCryptoHandshakeEvent, void(QuicSession::CryptoHandshakeEvent)); |
| MOCK_CONST_METHOD0(GetAlpnsToOffer, std::vector<std::string>()); |
| MOCK_CONST_METHOD1(SelectAlpn, |
| std::vector<QuicStringPiece>::const_iterator( |
| const std::vector<QuicStringPiece>&)); |
| MOCK_METHOD1(OnAlpnSelected, void(QuicStringPiece)); |
| |
| using QuicSession::ActivateStream; |
| |
| // Returns a QuicConsumedData that indicates all of |write_length| (and |fin| |
| // if set) has been consumed. |
| static QuicConsumedData ConsumeData(QuicStream* stream, |
| QuicStreamId id, |
| size_t write_length, |
| QuicStreamOffset offset, |
| StreamSendingState state); |
| |
| private: |
| std::unique_ptr<QuicCryptoStream> crypto_stream_; |
| }; |
| |
| class MockQuicCryptoStream : public QuicCryptoStream { |
| public: |
| explicit MockQuicCryptoStream(QuicSession* session); |
| |
| ~MockQuicCryptoStream() override; |
| |
| bool encryption_established() const override; |
| bool handshake_confirmed() const override; |
| const QuicCryptoNegotiatedParameters& crypto_negotiated_params() |
| const override; |
| CryptoMessageParser* crypto_message_parser() override; |
| |
| private: |
| QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_; |
| CryptoFramer crypto_framer_; |
| }; |
| |
| class MockQuicSpdySession : public QuicSpdySession { |
| public: |
| // Takes ownership of |connection|. |
| explicit MockQuicSpdySession(QuicConnection* connection); |
| // Takes ownership of |connection|. |
| MockQuicSpdySession(QuicConnection* connection, |
| bool create_mock_crypto_stream); |
| MockQuicSpdySession(const MockQuicSpdySession&) = delete; |
| MockQuicSpdySession& operator=(const MockQuicSpdySession&) = delete; |
| ~MockQuicSpdySession() override; |
| |
| QuicCryptoStream* GetMutableCryptoStream() override; |
| const QuicCryptoStream* GetCryptoStream() const override; |
| void SetCryptoStream(QuicCryptoStream* crypto_stream); |
| |
| void ReallyOnConnectionClosed(const QuicConnectionCloseFrame& frame, |
| ConnectionCloseSource source) { |
| QuicSession::OnConnectionClosed(frame, source); |
| } |
| |
| // From QuicSession. |
| MOCK_METHOD2(OnConnectionClosed, |
| void(const QuicConnectionCloseFrame& frame, |
| ConnectionCloseSource source)); |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id)); |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream)); |
| MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*()); |
| MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*()); |
| MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id)); |
| MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool()); |
| MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool()); |
| MOCK_METHOD5(WritevData, |
| QuicConsumedData(QuicStream* stream, |
| QuicStreamId id, |
| size_t write_length, |
| QuicStreamOffset offset, |
| StreamSendingState state)); |
| |
| MOCK_METHOD3(SendRstStream, |
| void(QuicStreamId stream_id, |
| QuicRstStreamErrorCode error, |
| QuicStreamOffset bytes_written)); |
| |
| MOCK_METHOD2(OnStreamHeaders, |
| void(QuicStreamId stream_id, QuicStringPiece headers_data)); |
| MOCK_METHOD2(OnStreamHeadersPriority, |
| void(QuicStreamId stream_id, |
| const spdy::SpdyStreamPrecedence& precedence)); |
| MOCK_METHOD3(OnStreamHeadersComplete, |
| void(QuicStreamId stream_id, bool fin, size_t frame_len)); |
| MOCK_METHOD4(OnStreamHeaderList, |
| void(QuicStreamId stream_id, |
| bool fin, |
| size_t frame_len, |
| const QuicHeaderList& header_list)); |
| MOCK_METHOD2(OnPromiseHeaders, |
| void(QuicStreamId stream_id, QuicStringPiece headers_data)); |
| MOCK_METHOD3(OnPromiseHeadersComplete, |
| void(QuicStreamId stream_id, |
| QuicStreamId promised_stream_id, |
| size_t frame_len)); |
| MOCK_METHOD4(OnPromiseHeaderList, |
| void(QuicStreamId stream_id, |
| QuicStreamId promised_stream_id, |
| size_t frame_len, |
| const QuicHeaderList& header_list)); |
| MOCK_METHOD2(OnPriorityFrame, |
| void(QuicStreamId id, |
| const spdy::SpdyStreamPrecedence& precedence)); |
| |
| MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta)); |
| MOCK_METHOD4( |
| OnStreamFrameData, |
| void(QuicStreamId stream_id, const char* data, size_t len, bool fin)); |
| |
| using QuicSession::ActivateStream; |
| |
| private: |
| std::unique_ptr<QuicCryptoStream> crypto_stream_; |
| }; |
| |
| class TestQuicSpdyServerSession : public QuicServerSessionBase { |
| public: |
| // Takes ownership of |connection|. |
| TestQuicSpdyServerSession(QuicConnection* connection, |
| const QuicConfig& config, |
| const ParsedQuicVersionVector& supported_versions, |
| const QuicCryptoServerConfig* crypto_config, |
| QuicCompressedCertsCache* compressed_certs_cache); |
| TestQuicSpdyServerSession(const TestQuicSpdyServerSession&) = delete; |
| TestQuicSpdyServerSession& operator=(const TestQuicSpdyServerSession&) = |
| delete; |
| ~TestQuicSpdyServerSession() override; |
| |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id)); |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream)); |
| MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*()); |
| MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*()); |
| MOCK_CONST_METHOD1(SelectAlpn, |
| std::vector<QuicStringPiece>::const_iterator( |
| const std::vector<QuicStringPiece>&)); |
| QuicCryptoServerStreamBase* CreateQuicCryptoServerStream( |
| const QuicCryptoServerConfig* crypto_config, |
| QuicCompressedCertsCache* compressed_certs_cache) override; |
| |
| // Override to not send max header list size. |
| void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override; |
| |
| QuicCryptoServerStream* GetMutableCryptoStream() override; |
| |
| const QuicCryptoServerStream* GetCryptoStream() const override; |
| |
| MockQuicCryptoServerStreamHelper* helper() { return &helper_; } |
| |
| private: |
| MockQuicSessionVisitor visitor_; |
| MockQuicCryptoServerStreamHelper helper_; |
| }; |
| |
| // A test implementation of QuicClientPushPromiseIndex::Delegate. |
| class TestPushPromiseDelegate : public QuicClientPushPromiseIndex::Delegate { |
| public: |
| // |match| sets the validation result for checking whether designated header |
| // fields match for promise request and client request. |
| explicit TestPushPromiseDelegate(bool match); |
| |
| bool CheckVary(const spdy::SpdyHeaderBlock& client_request, |
| const spdy::SpdyHeaderBlock& promise_request, |
| const spdy::SpdyHeaderBlock& promise_response) override; |
| |
| void OnRendezvousResult(QuicSpdyStream* stream) override; |
| |
| QuicSpdyStream* rendezvous_stream() { return rendezvous_stream_; } |
| bool rendezvous_fired() { return rendezvous_fired_; } |
| |
| private: |
| bool match_; |
| bool rendezvous_fired_; |
| QuicSpdyStream* rendezvous_stream_; |
| }; |
| |
| class TestQuicSpdyClientSession : public QuicSpdyClientSessionBase { |
| public: |
| TestQuicSpdyClientSession(QuicConnection* connection, |
| const QuicConfig& config, |
| const ParsedQuicVersionVector& supported_versions, |
| const QuicServerId& server_id, |
| QuicCryptoClientConfig* crypto_config); |
| TestQuicSpdyClientSession(const TestQuicSpdyClientSession&) = delete; |
| TestQuicSpdyClientSession& operator=(const TestQuicSpdyClientSession&) = |
| delete; |
| ~TestQuicSpdyClientSession() override; |
| |
| bool IsAuthorized(const std::string& authority) override; |
| |
| // QuicSpdyClientSessionBase |
| MOCK_METHOD1(OnProofValid, |
| void(const QuicCryptoClientConfig::CachedState& cached)); |
| MOCK_METHOD1(OnProofVerifyDetailsAvailable, |
| void(const ProofVerifyDetails& verify_details)); |
| |
| // TestQuicSpdyClientSession |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id)); |
| MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream)); |
| MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*()); |
| MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*()); |
| MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id)); |
| MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool()); |
| MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool()); |
| MOCK_CONST_METHOD0(GetAlpnsToOffer, std::vector<std::string>()); |
| |
| // Override to not send max header list size. |
| void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override; |
| QuicCryptoClientStream* GetMutableCryptoStream() override; |
| const QuicCryptoClientStream* GetCryptoStream() const override; |
| |
| // Override to save sent crypto handshake messages. |
| void OnCryptoHandshakeMessageSent( |
| const CryptoHandshakeMessage& message) override { |
| sent_crypto_handshake_messages_.push_back(message); |
| } |
| |
| const std::vector<CryptoHandshakeMessage>& sent_crypto_handshake_messages() |
| const { |
| return sent_crypto_handshake_messages_; |
| } |
| |
| private: |
| std::unique_ptr<QuicCryptoClientStream> crypto_stream_; |
| QuicClientPushPromiseIndex push_promise_index_; |
| std::vector<CryptoHandshakeMessage> sent_crypto_handshake_messages_; |
| }; |
| |
| class MockPacketWriter : public QuicPacketWriter { |
| public: |
| MockPacketWriter(); |
| MockPacketWriter(const MockPacketWriter&) = delete; |
| MockPacketWriter& operator=(const MockPacketWriter&) = delete; |
| ~MockPacketWriter() override; |
| |
| MOCK_METHOD5(WritePacket, |
| WriteResult(const char* buffer, |
| size_t buf_len, |
| const QuicIpAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| PerPacketOptions* options)); |
| MOCK_CONST_METHOD0(IsWriteBlocked, bool()); |
| MOCK_METHOD0(SetWritable, void()); |
| MOCK_CONST_METHOD1(GetMaxPacketSize, |
| QuicByteCount(const QuicSocketAddress& peer_address)); |
| MOCK_CONST_METHOD0(SupportsReleaseTime, bool()); |
| MOCK_CONST_METHOD0(IsBatchMode, bool()); |
| MOCK_METHOD2(GetNextWriteLocation, |
| char*(const QuicIpAddress& self_address, |
| const QuicSocketAddress& peer_address)); |
| MOCK_METHOD0(Flush, WriteResult()); |
| }; |
| |
| class MockSendAlgorithm : public SendAlgorithmInterface { |
| public: |
| MockSendAlgorithm(); |
| MockSendAlgorithm(const MockSendAlgorithm&) = delete; |
| MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete; |
| ~MockSendAlgorithm() override; |
| |
| MOCK_METHOD2(SetFromConfig, |
| void(const QuicConfig& config, Perspective perspective)); |
| MOCK_METHOD1(SetInitialCongestionWindowInPackets, |
| void(QuicPacketCount packets)); |
| MOCK_METHOD1(SetMaxCongestionWindow, |
| void(QuicByteCount max_congestion_window)); |
| MOCK_METHOD5(OnCongestionEvent, |
| void(bool rtt_updated, |
| QuicByteCount bytes_in_flight, |
| QuicTime event_time, |
| const AckedPacketVector& acked_packets, |
| const LostPacketVector& lost_packets)); |
| MOCK_METHOD5(OnPacketSent, |
| void(QuicTime, |
| QuicByteCount, |
| QuicPacketNumber, |
| QuicByteCount, |
| HasRetransmittableData)); |
| MOCK_METHOD1(OnRetransmissionTimeout, void(bool)); |
| MOCK_METHOD0(OnConnectionMigration, void()); |
| MOCK_METHOD0(RevertRetransmissionTimeout, void()); |
| MOCK_METHOD1(CanSend, bool(QuicByteCount)); |
| MOCK_CONST_METHOD1(PacingRate, QuicBandwidth(QuicByteCount)); |
| MOCK_CONST_METHOD0(BandwidthEstimate, QuicBandwidth(void)); |
| MOCK_CONST_METHOD0(HasReliableBandwidthEstimate, bool()); |
| MOCK_METHOD1(OnRttUpdated, void(QuicPacketNumber)); |
| MOCK_CONST_METHOD0(GetCongestionWindow, QuicByteCount()); |
| MOCK_CONST_METHOD0(GetDebugState, std::string()); |
| MOCK_CONST_METHOD0(InSlowStart, bool()); |
| MOCK_CONST_METHOD0(InRecovery, bool()); |
| MOCK_CONST_METHOD0(ShouldSendProbingPacket, bool()); |
| MOCK_CONST_METHOD0(GetSlowStartThreshold, QuicByteCount()); |
| MOCK_CONST_METHOD0(GetCongestionControlType, CongestionControlType()); |
| MOCK_METHOD3(AdjustNetworkParameters, |
| void(QuicBandwidth, QuicTime::Delta, bool)); |
| MOCK_METHOD1(OnApplicationLimited, void(QuicByteCount)); |
| }; |
| |
| class MockLossAlgorithm : public LossDetectionInterface { |
| public: |
| MockLossAlgorithm(); |
| MockLossAlgorithm(const MockLossAlgorithm&) = delete; |
| MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete; |
| ~MockLossAlgorithm() override; |
| |
| MOCK_CONST_METHOD0(GetLossDetectionType, LossDetectionType()); |
| MOCK_METHOD6(DetectLosses, |
| void(const QuicUnackedPacketMap& unacked_packets, |
| QuicTime time, |
| const RttStats& rtt_stats, |
| QuicPacketNumber largest_recently_acked, |
| const AckedPacketVector& packets_acked, |
| LostPacketVector* packets_lost)); |
| MOCK_CONST_METHOD0(GetLossTimeout, QuicTime()); |
| MOCK_METHOD5(SpuriousLossDetected, |
| void(const QuicUnackedPacketMap&, |
| const RttStats&, |
| QuicTime, |
| QuicPacketNumber, |
| QuicPacketNumber)); |
| }; |
| |
| class MockAckListener : public QuicAckListenerInterface { |
| public: |
| MockAckListener(); |
| MockAckListener(const MockAckListener&) = delete; |
| MockAckListener& operator=(const MockAckListener&) = delete; |
| |
| MOCK_METHOD2(OnPacketAcked, |
| void(int acked_bytes, QuicTime::Delta ack_delay_time)); |
| |
| MOCK_METHOD1(OnPacketRetransmitted, void(int retransmitted_bytes)); |
| |
| protected: |
| // Object is ref counted. |
| ~MockAckListener() override; |
| }; |
| |
| class MockNetworkChangeVisitor |
| : public QuicSentPacketManager::NetworkChangeVisitor { |
| public: |
| MockNetworkChangeVisitor(); |
| MockNetworkChangeVisitor(const MockNetworkChangeVisitor&) = delete; |
| MockNetworkChangeVisitor& operator=(const MockNetworkChangeVisitor&) = delete; |
| ~MockNetworkChangeVisitor() override; |
| |
| MOCK_METHOD0(OnCongestionChange, void()); |
| MOCK_METHOD1(OnPathMtuIncreased, void(QuicPacketLength)); |
| }; |
| |
| class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor { |
| public: |
| MockQuicConnectionDebugVisitor(); |
| ~MockQuicConnectionDebugVisitor() override; |
| |
| MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame&)); |
| |
| MOCK_METHOD3(OnPacketSent, |
| void(const SerializedPacket&, TransmissionType, QuicTime)); |
| |
| MOCK_METHOD0(OnPingSent, void()); |
| |
| MOCK_METHOD3(OnPacketReceived, |
| void(const QuicSocketAddress&, |
| const QuicSocketAddress&, |
| const QuicEncryptedPacket&)); |
| |
| MOCK_METHOD1(OnIncorrectConnectionId, void(QuicConnectionId)); |
| |
| MOCK_METHOD1(OnProtocolVersionMismatch, void(ParsedQuicVersion)); |
| |
| MOCK_METHOD1(OnPacketHeader, void(const QuicPacketHeader& header)); |
| |
| MOCK_METHOD1(OnSuccessfulVersionNegotiation, void(const ParsedQuicVersion&)); |
| |
| MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame&)); |
| |
| MOCK_METHOD1(OnCryptoFrame, void(const QuicCryptoFrame&)); |
| |
| MOCK_METHOD1(OnStopWaitingFrame, void(const QuicStopWaitingFrame&)); |
| |
| MOCK_METHOD1(OnRstStreamFrame, void(const QuicRstStreamFrame&)); |
| |
| MOCK_METHOD1(OnConnectionCloseFrame, void(const QuicConnectionCloseFrame&)); |
| |
| MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame&)); |
| |
| MOCK_METHOD1(OnNewConnectionIdFrame, void(const QuicNewConnectionIdFrame&)); |
| |
| MOCK_METHOD1(OnRetireConnectionIdFrame, |
| void(const QuicRetireConnectionIdFrame&)); |
| |
| MOCK_METHOD1(OnNewTokenFrame, void(const QuicNewTokenFrame&)); |
| |
| MOCK_METHOD1(OnMessageFrame, void(const QuicMessageFrame&)); |
| |
| MOCK_METHOD1(OnStopSendingFrame, void(const QuicStopSendingFrame&)); |
| |
| MOCK_METHOD1(OnPathChallengeFrame, void(const QuicPathChallengeFrame&)); |
| |
| MOCK_METHOD1(OnPathResponseFrame, void(const QuicPathResponseFrame&)); |
| |
| MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket&)); |
| |
| MOCK_METHOD1(OnVersionNegotiationPacket, |
| void(const QuicVersionNegotiationPacket&)); |
| |
| MOCK_METHOD3(OnRetryPacket, |
| void(QuicConnectionId, QuicConnectionId, QuicStringPiece)); |
| }; |
| |
| class MockReceivedPacketManager : public QuicReceivedPacketManager { |
| public: |
| explicit MockReceivedPacketManager(QuicConnectionStats* stats); |
| ~MockReceivedPacketManager() override; |
| |
| MOCK_METHOD2(RecordPacketReceived, |
| void(const QuicPacketHeader& header, QuicTime receipt_time)); |
| MOCK_METHOD1(IsMissing, bool(QuicPacketNumber packet_number)); |
| MOCK_CONST_METHOD1(IsAwaitingPacket, bool(QuicPacketNumber packet_number)); |
| MOCK_METHOD1(UpdatePacketInformationSentByPeer, |
| void(const QuicStopWaitingFrame& stop_waiting)); |
| MOCK_CONST_METHOD0(HasNewMissingPackets, bool(void)); |
| MOCK_CONST_METHOD0(ack_frame_updated, bool(void)); |
| }; |
| |
| class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface { |
| public: |
| MockPacketCreatorDelegate(); |
| MockPacketCreatorDelegate(const MockPacketCreatorDelegate&) = delete; |
| MockPacketCreatorDelegate& operator=(const MockPacketCreatorDelegate&) = |
| delete; |
| ~MockPacketCreatorDelegate() override; |
| |
| MOCK_METHOD0(GetPacketBuffer, char*()); |
| MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet)); |
| MOCK_METHOD2(OnUnrecoverableError, void(QuicErrorCode, const std::string&)); |
| MOCK_METHOD2(ShouldGeneratePacket, |
| bool(HasRetransmittableData retransmittable, |
| IsHandshake handshake)); |
| MOCK_METHOD0(MaybeBundleAckOpportunistically, const QuicFrames()); |
| }; |
| |
| class MockSessionNotifier : public SessionNotifierInterface { |
| public: |
| MockSessionNotifier(); |
| ~MockSessionNotifier() override; |
| |
| MOCK_METHOD3(OnFrameAcked, bool(const QuicFrame&, QuicTime::Delta, QuicTime)); |
| MOCK_METHOD1(OnStreamFrameRetransmitted, void(const QuicStreamFrame&)); |
| MOCK_METHOD1(OnFrameLost, void(const QuicFrame&)); |
| MOCK_METHOD2(RetransmitFrames, |
| void(const QuicFrames&, TransmissionType type)); |
| MOCK_CONST_METHOD1(IsFrameOutstanding, bool(const QuicFrame&)); |
| MOCK_CONST_METHOD0(HasUnackedCryptoData, bool()); |
| MOCK_CONST_METHOD0(HasUnackedStreamData, bool()); |
| }; |
| |
| // Creates a client session for testing. |
| // |
| // server_id: The server id associated with this stream. |
| // connection_start_time: The time to set for the connection clock. |
| // Needed for strike-register nonce verification. The client |
| // connection_start_time should be synchronized witht the server |
| // start time, otherwise nonce verification will fail. |
| // supported_versions: Set of QUIC versions this client supports. |
| // helper: Pointer to the MockQuicConnectionHelper to use for the session. |
| // crypto_client_config: Pointer to the crypto client config. |
| // client_connection: Pointer reference for newly created |
| // connection. This object will be owned by the |
| // client_session. |
| // client_session: Pointer reference for the newly created client |
| // session. The new object will be owned by the caller. |
| void CreateClientSessionForTest( |
| QuicServerId server_id, |
| QuicTime::Delta connection_start_time, |
| const ParsedQuicVersionVector& supported_versions, |
| MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| QuicCryptoClientConfig* crypto_client_config, |
| PacketSavingConnection** client_connection, |
| TestQuicSpdyClientSession** client_session); |
| |
| // Creates a server session for testing. |
| // |
| // server_id: The server id associated with this stream. |
| // connection_start_time: The time to set for the connection clock. |
| // Needed for strike-register nonce verification. The server |
| // connection_start_time should be synchronized witht the client |
| // start time, otherwise nonce verification will fail. |
| // supported_versions: Set of QUIC versions this server supports. |
| // helper: Pointer to the MockQuicConnectionHelper to use for the session. |
| // crypto_server_config: Pointer to the crypto server config. |
| // server_connection: Pointer reference for newly created |
| // connection. This object will be owned by the |
| // server_session. |
| // server_session: Pointer reference for the newly created server |
| // session. The new object will be owned by the caller. |
| void CreateServerSessionForTest( |
| QuicServerId server_id, |
| QuicTime::Delta connection_start_time, |
| ParsedQuicVersionVector supported_versions, |
| MockQuicConnectionHelper* helper, |
| MockAlarmFactory* alarm_factory, |
| QuicCryptoServerConfig* crypto_server_config, |
| QuicCompressedCertsCache* compressed_certs_cache, |
| PacketSavingConnection** server_connection, |
| TestQuicSpdyServerSession** server_session); |
| |
| // Verifies that the relative error of |actual| with respect to |expected| is |
| // no more than |margin|. |
| // Please use EXPECT_APPROX_EQ, a wrapper around this function, for better error |
| // report. |
| template <typename T> |
| void ExpectApproxEq(T expected, T actual, float relative_margin) { |
| // If |relative_margin| > 1 and T is an unsigned type, the comparison will |
| // underflow. |
| ASSERT_LE(relative_margin, 1); |
| ASSERT_GE(relative_margin, 0); |
| |
| T absolute_margin = expected * relative_margin; |
| |
| EXPECT_GE(expected + absolute_margin, actual) << "actual value too big"; |
| EXPECT_LE(expected - absolute_margin, actual) << "actual value too small"; |
| } |
| |
| #define EXPECT_APPROX_EQ(expected, actual, relative_margin) \ |
| do { \ |
| SCOPED_TRACE(testing::Message() << "relative_margin:" << relative_margin); \ |
| quic::test::ExpectApproxEq(expected, actual, relative_margin); \ |
| } while (0) |
| |
| template <typename T> |
| QuicHeaderList AsHeaderList(const T& container) { |
| QuicHeaderList l; |
| // No need to enforce header list size limits again in this handler. |
| l.set_max_header_list_size(UINT_MAX); |
| l.OnHeaderBlockStart(); |
| size_t total_size = 0; |
| for (auto p : container) { |
| total_size += p.first.size() + p.second.size(); |
| l.OnHeader(p.first, p.second); |
| } |
| l.OnHeaderBlockEnd(total_size, total_size); |
| return l; |
| } |
| |
| // Utility function that stores |str|'s data in |iov|. |
| inline void MakeIOVector(QuicStringPiece str, struct iovec* iov) { |
| iov->iov_base = const_cast<char*>(str.data()); |
| iov->iov_len = static_cast<size_t>(str.size()); |
| } |
| |
| // Helper functions for stream ids, to allow test logic to abstract over the |
| // HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used |
| // per HTTP transaction). |
| QuicStreamId GetNthClientInitiatedBidirectionalStreamId( |
| QuicTransportVersion version, |
| int n); |
| QuicStreamId GetNthServerInitiatedBidirectionalStreamId( |
| QuicTransportVersion version, |
| int n); |
| QuicStreamId GetNthServerInitiatedUnidirectionalStreamId( |
| QuicTransportVersion version, |
| int n); |
| QuicStreamId GetNthClientInitiatedUnidirectionalStreamId( |
| QuicTransportVersion version, |
| int n); |
| |
| StreamType DetermineStreamType(QuicStreamId id, |
| QuicTransportVersion version, |
| Perspective perspective, |
| bool is_incoming, |
| StreamType default_type); |
| |
| // Utility function that stores message_data in |storage| and returns a |
| // QuicMemSliceSpan. |
| QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator, |
| QuicStringPiece message_data, |
| QuicMemSliceStorage* storage); |
| |
| // Used to compare ReceivedPacketInfo. |
| MATCHER_P(ReceivedPacketInfoEquals, info, "") { |
| return info.ToString() == arg.ToString(); |
| } |
| |
| MATCHER_P(ReceivedPacketInfoConnectionIdEquals, destination_connection_id, "") { |
| return arg.destination_connection_id == destination_connection_id; |
| } |
| |
| MATCHER_P2(InRange, min, max, "") { |
| return arg >= min && arg <= max; |
| } |
| |
| // A GMock matcher that prints expected and actual QuicErrorCode strings |
| // upon failure. Example usage: |
| // EXPECT_THAT(stream_->connection_error()), IsError(QUIC_INTERNAL_ERROR)); |
| MATCHER_P(IsError, |
| expected, |
| QuicStrCat(negation ? "isn't equal to " : "is equal to ", |
| QuicErrorCodeToString(expected))) { |
| *result_listener << QuicErrorCodeToString(arg); |
| return arg == expected; |
| } |
| |
| // Shorthand for IsError(QUIC_NO_ERROR). |
| // Example usage: EXPECT_THAT(stream_->connection_error(), IsQuicNoError()); |
| MATCHER(IsQuicNoError, |
| QuicStrCat(negation ? "isn't equal to " : "is equal to ", |
| QuicErrorCodeToString(QUIC_NO_ERROR))) { |
| *result_listener << QuicErrorCodeToString(arg); |
| return arg == QUIC_NO_ERROR; |
| } |
| |
| // A GMock matcher that prints expected and actual QuicRstStreamErrorCode |
| // strings upon failure. Example usage: |
| // EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR)); |
| MATCHER_P(IsStreamError, |
| expected, |
| QuicStrCat(negation ? "isn't equal to " : "is equal to ", |
| QuicRstStreamErrorCodeToString(expected))) { |
| *result_listener << QuicRstStreamErrorCodeToString(arg); |
| return arg == expected; |
| } |
| |
| // Shorthand for IsStreamError(QUIC_STREAM_NO_ERROR). Example usage: |
| // EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError()); |
| MATCHER(IsQuicStreamNoError, |
| QuicStrCat(negation ? "isn't equal to " : "is equal to ", |
| QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) { |
| *result_listener << QuicRstStreamErrorCodeToString(arg); |
| return arg == QUIC_STREAM_NO_ERROR; |
| } |
| |
| } // namespace test |
| } // namespace quic |
| |
| #endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ |
