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