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