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