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