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