summaryrefslogtreecommitdiff
path: root/chromium/net/quic/test_tools/quic_test_utils.h
diff options
context:
space:
mode:
Diffstat (limited to 'chromium/net/quic/test_tools/quic_test_utils.h')
-rw-r--r--chromium/net/quic/test_tools/quic_test_utils.h159
1 files changed, 114 insertions, 45 deletions
diff --git a/chromium/net/quic/test_tools/quic_test_utils.h b/chromium/net/quic/test_tools/quic_test_utils.h
index 64a9d30ada2..06c343189b5 100644
--- a/chromium/net/quic/test_tools/quic_test_utils.h
+++ b/chromium/net/quic/test_tools/quic_test_utils.h
@@ -12,6 +12,7 @@
#include "base/strings/string_piece.h"
#include "net/quic/congestion_control/send_algorithm_interface.h"
+#include "net/quic/quic_ack_notifier.h"
#include "net/quic/quic_connection.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_session.h"
@@ -25,12 +26,26 @@ namespace net {
namespace test {
+static const QuicGuid kTestGuid = 42;
+static const int kTestPort = 123;
+
+// Upper limit on versions we support.
+QuicVersion QuicVersionMax();
+
+// Lower limit on versions we support.
+QuicVersion QuicVersionMin();
+
+// Returns an address for 127.0.0.1.
+IPAddressNumber Loopback4();
+
void CompareCharArraysWithHexError(const std::string& description,
const char* actual,
const int actual_len,
const char* expected,
const int expected_len);
+bool DecodeHexString(const base::StringPiece& hex, std::string* bytes);
+
// Returns the length of a QuicPacket that is capable of holding either a
// stream frame or a minimal ack frame. Sets |*payload_length| to the number
// of bytes of stream data that will fit in such a packet.
@@ -48,6 +63,25 @@ size_t GetMinStreamFrameSize(QuicVersion version);
// Returns QuicConfig set to default values.
QuicConfig DefaultQuicConfig();
+template<typename SaveType>
+class ValueRestore {
+ public:
+ ValueRestore(SaveType* name, SaveType value)
+ : name_(name),
+ value_(*name) {
+ *name_ = value;
+ }
+ ~ValueRestore() {
+ *name_ = value_;
+ }
+
+ private:
+ SaveType* name_;
+ SaveType value_;
+
+ DISALLOW_COPY_AND_ASSIGN(ValueRestore);
+};
+
class MockFramerVisitor : public QuicFramerVisitorInterface {
public:
MockFramerVisitor();
@@ -62,6 +96,7 @@ class MockFramerVisitor : public QuicFramerVisitorInterface {
void(const QuicVersionNegotiationPacket& packet));
MOCK_METHOD0(OnRevivedPacket, void());
// The constructor sets this up to return true by default.
+ MOCK_METHOD1(OnUnauthenticatedHeader, bool(const QuicPacketHeader& header));
MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload));
MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
@@ -91,6 +126,7 @@ class NoOpFramerVisitor : public QuicFramerVisitorInterface {
const QuicVersionNegotiationPacket& packet) OVERRIDE {}
virtual void OnRevivedPacket() OVERRIDE {}
virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
+ virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
@@ -129,6 +165,9 @@ class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
FramerVisitorCapturingFrames();
virtual ~FramerVisitorCapturingFrames();
+ // Reset the visitor to it's initial state.
+ void Reset();
+
// NoOpFramerVisitor
virtual void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) OVERRIDE;
@@ -147,6 +186,9 @@ class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
const std::vector<QuicStreamFrame>* stream_frames() const {
return &stream_frames_;
}
+ const std::vector<string*>& stream_data() const {
+ return stream_data_;
+ }
QuicAckFrame* ack() { return ack_.get(); }
QuicCongestionFeedbackFrame* feedback() { return feedback_.get(); }
QuicRstStreamFrame* rst() { return rst_.get(); }
@@ -160,6 +202,7 @@ class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
size_t frame_count_;
QuicPacketHeader header_;
std::vector<QuicStreamFrame> stream_frames_;
+ std::vector<std::string*> stream_data_;
scoped_ptr<QuicAckFrame> ack_;
scoped_ptr<QuicCongestionFeedbackFrame> feedback_;
scoped_ptr<QuicRstStreamFrame> rst_;
@@ -178,11 +221,12 @@ class MockConnectionVisitor : public QuicConnectionVisitorInterface {
MOCK_METHOD1(OnStreamFrames, bool(const std::vector<QuicStreamFrame>& frame));
MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
- MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
+ MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer));
MOCK_METHOD0(OnCanWrite, bool());
MOCK_CONST_METHOD0(HasPendingHandshake, bool());
MOCK_METHOD1(OnSuccessfulVersionNegotiation,
void(const QuicVersion& version));
+ MOCK_METHOD0(OnConfigNegotiated, void());
private:
DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor);
@@ -197,10 +241,6 @@ class MockHelper : public QuicConnectionHelperInterface {
const QuicClock* GetClock() const;
QuicRandom* GetRandomGenerator();
void AdvanceTime(QuicTime::Delta delta);
- MOCK_METHOD2(WritePacketToWire, int(const QuicEncryptedPacket& packet,
- int* error));
- MOCK_METHOD0(IsWriteBlockedDataBuffered, bool());
- MOCK_METHOD1(IsWriteBlocked, bool(int stream_id));
virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate);
private:
@@ -210,12 +250,17 @@ class MockHelper : public QuicConnectionHelperInterface {
class MockConnection : public QuicConnection {
public:
- // Uses a MockHelper.
- MockConnection(QuicGuid guid, IPEndPoint address, bool is_server);
+ // Uses a MockHelper, GUID of 42, and 127.0.0.1:123.
+ explicit MockConnection(bool is_server);
+
+ // Uses a MockHelper, GUID of 42.
+ MockConnection(IPEndPoint address,
+ bool is_server);
+
+ // Uses a MockHelper, and 127.0.0.1:123
MockConnection(QuicGuid guid,
- IPEndPoint address,
- QuicConnectionHelperInterface* helper,
bool is_server);
+
virtual ~MockConnection();
// If the constructor that uses a MockHelper has been used then this method
@@ -247,23 +292,20 @@ class MockConnection : public QuicConnection {
}
private:
- const bool has_mock_helper_;
+ scoped_ptr<QuicPacketWriter> writer_;
+ scoped_ptr<QuicConnectionHelperInterface> helper_;
DISALLOW_COPY_AND_ASSIGN(MockConnection);
};
class PacketSavingConnection : public MockConnection {
public:
- PacketSavingConnection(QuicGuid guid, IPEndPoint address, bool is_server);
+ explicit PacketSavingConnection(bool is_server);
virtual ~PacketSavingConnection();
- virtual bool SendOrQueuePacket(
- EncryptionLevel level,
- QuicPacketSequenceNumber sequence_number,
- QuicPacket* packet,
- QuicPacketEntropyHash entropy_hash,
- HasRetransmittableData has_retransmittable_data,
- Force forced) OVERRIDE;
+ virtual bool SendOrQueuePacket(EncryptionLevel level,
+ const SerializedPacket& packet,
+ TransmissionType transmission_type) OVERRIDE;
std::vector<QuicPacket*> packets_;
std::vector<QuicEncryptedPacket*> encrypted_packets_;
@@ -274,24 +316,26 @@ class PacketSavingConnection : public MockConnection {
class MockSession : public QuicSession {
public:
- MockSession(QuicConnection* connection, bool is_server);
+ explicit MockSession(QuicConnection* connection);
virtual ~MockSession();
MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
const IPEndPoint& peer_address,
const QuicPacketHeader& header,
const std::vector<QuicStreamFrame>& frame));
- MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
- MOCK_METHOD1(CreateIncomingReliableStream,
- ReliableQuicStream*(QuicStreamId id));
+ MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer));
+ MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id));
MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*());
- MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
- MOCK_METHOD5(WritevData, QuicConsumedData(QuicStreamId id,
- const struct iovec* iov,
- int count,
- QuicStreamOffset offset,
- bool fin));
+ MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*());
+ MOCK_METHOD6(WritevData,
+ QuicConsumedData(QuicStreamId id,
+ const struct iovec* iov,
+ int count,
+ QuicStreamOffset offset,
+ bool fin,
+ QuicAckNotifier::DelegateInterface*));
MOCK_METHOD0(IsHandshakeComplete, bool());
+ MOCK_METHOD0(IsCryptoHandshakeConfirmed, bool());
private:
DISALLOW_COPY_AND_ASSIGN(MockSession);
@@ -299,14 +343,11 @@ class MockSession : public QuicSession {
class TestSession : public QuicSession {
public:
- TestSession(QuicConnection* connection,
- const QuicConfig& config,
- bool is_server);
+ TestSession(QuicConnection* connection, const QuicConfig& config);
virtual ~TestSession();
- MOCK_METHOD1(CreateIncomingReliableStream,
- ReliableQuicStream*(QuicStreamId id));
- MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
+ MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id));
+ MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*());
void SetCryptoStream(QuicCryptoStream* stream);
@@ -317,29 +358,47 @@ class TestSession : public QuicSession {
DISALLOW_COPY_AND_ASSIGN(TestSession);
};
+class MockPacketWriter : public QuicPacketWriter {
+ public:
+ MockPacketWriter();
+ virtual ~MockPacketWriter();
+
+ MOCK_METHOD5(WritePacket,
+ WriteResult(const char* buffer,
+ size_t buf_len,
+ const IPAddressNumber& self_address,
+ const IPEndPoint& peer_address,
+ QuicBlockedWriterInterface* blocked_writer));
+ MOCK_CONST_METHOD0(IsWriteBlockedDataBuffered, bool());
+};
+
class MockSendAlgorithm : public SendAlgorithmInterface {
public:
MockSendAlgorithm();
virtual ~MockSendAlgorithm();
+ MOCK_METHOD2(SetFromConfig, void(const QuicConfig& config, bool is_server));
+ MOCK_METHOD1(SetMaxPacketSize, void(QuicByteCount max_packet_size));
MOCK_METHOD3(OnIncomingQuicCongestionFeedbackFrame,
void(const QuicCongestionFeedbackFrame&,
QuicTime feedback_receive_time,
const SentPacketsMap&));
- MOCK_METHOD3(OnIncomingAck,
+ MOCK_METHOD3(OnPacketAcked,
void(QuicPacketSequenceNumber, QuicByteCount, QuicTime::Delta));
- MOCK_METHOD1(OnIncomingLoss, void(QuicTime));
- MOCK_METHOD5(SentPacket,
+ MOCK_METHOD2(OnPacketLost, void(QuicPacketSequenceNumber, QuicTime));
+ MOCK_METHOD5(OnPacketSent,
bool(QuicTime sent_time, QuicPacketSequenceNumber, QuicByteCount,
- Retransmission, HasRetransmittableData));
- MOCK_METHOD2(AbandoningPacket, void(QuicPacketSequenceNumber sequence_number,
+ TransmissionType, HasRetransmittableData));
+ MOCK_METHOD0(OnRetransmissionTimeout, void());
+ MOCK_METHOD2(OnPacketAbandoned, void(QuicPacketSequenceNumber sequence_number,
QuicByteCount abandoned_bytes));
- MOCK_METHOD4(TimeUntilSend, QuicTime::Delta(QuicTime now, Retransmission,
+ MOCK_METHOD4(TimeUntilSend, QuicTime::Delta(QuicTime now, TransmissionType,
HasRetransmittableData,
IsHandshake));
- MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
- MOCK_METHOD0(SmoothedRtt, QuicTime::Delta(void));
- MOCK_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
+ MOCK_CONST_METHOD0(BandwidthEstimate, QuicBandwidth(void));
+ MOCK_CONST_METHOD0(SmoothedRtt, QuicTime::Delta(void));
+ MOCK_CONST_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
+ MOCK_CONST_METHOD0(GetCongestionWindow, QuicByteCount());
private:
DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm);
@@ -348,13 +407,23 @@ class MockSendAlgorithm : public SendAlgorithmInterface {
class TestEntropyCalculator :
public QuicReceivedEntropyHashCalculatorInterface {
public:
- TestEntropyCalculator() { }
- virtual ~TestEntropyCalculator() { }
+ TestEntropyCalculator();
+ virtual ~TestEntropyCalculator();
virtual QuicPacketEntropyHash EntropyHash(
QuicPacketSequenceNumber sequence_number) const OVERRIDE;
};
+class MockEntropyCalculator : public TestEntropyCalculator {
+ public:
+ MockEntropyCalculator();
+ virtual ~MockEntropyCalculator();
+
+ MOCK_CONST_METHOD1(
+ EntropyHash,
+ QuicPacketEntropyHash(QuicPacketSequenceNumber sequence_number));
+};
+
class TestDecompressorVisitor : public QuicSpdyDecompressor::Visitor {
public:
virtual ~TestDecompressorVisitor() {}
View Lorry Controller Status