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 QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
8 #define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
9
10 #include <cstdint>
11 #include <memory>
12 #include <string>
13 #include <utility>
14 #include <vector>
15
16 #include "absl/container/flat_hash_map.h"
17 #include "absl/strings/ascii.h"
18 #include "absl/strings/str_cat.h"
19 #include "absl/strings/string_view.h"
20 #include "quiche/quic/core/congestion_control/loss_detection_interface.h"
21 #include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
22 #include "quiche/quic/core/crypto/transport_parameters.h"
23 #include "quiche/quic/core/http/http_decoder.h"
24 #include "quiche/quic/core/http/quic_server_session_base.h"
25 #include "quiche/quic/core/http/quic_spdy_client_session_base.h"
26 #include "quiche/quic/core/http/quic_spdy_session.h"
27 #include "quiche/quic/core/quic_connection.h"
28 #include "quiche/quic/core/quic_connection_id.h"
29 #include "quiche/quic/core/quic_error_codes.h"
30 #include "quiche/quic/core/quic_framer.h"
31 #include "quiche/quic/core/quic_packet_writer.h"
32 #include "quiche/quic/core/quic_packets.h"
33 #include "quiche/quic/core/quic_path_validator.h"
34 #include "quiche/quic/core/quic_sent_packet_manager.h"
35 #include "quiche/quic/core/quic_server_id.h"
36 #include "quiche/quic/core/quic_types.h"
37 #include "quiche/quic/core/quic_utils.h"
38 #include "quiche/quic/platform/api/quic_socket_address.h"
39 #include "quiche/quic/test_tools/mock_clock.h"
40 #include "quiche/quic/test_tools/mock_connection_id_generator.h"
41 #include "quiche/quic/test_tools/mock_quic_session_visitor.h"
42 #include "quiche/quic/test_tools/mock_random.h"
43 #include "quiche/quic/test_tools/quic_framer_peer.h"
44 #include "quiche/quic/test_tools/simple_quic_framer.h"
45 #include "quiche/common/capsule.h"
46 #include "quiche/common/simple_buffer_allocator.h"
47 #include "quiche/spdy/core/http2_header_block.h"
48
49 namespace quic {
50
51 namespace test {
52
53 // A generic predictable connection ID suited for testing.
54 QuicConnectionId TestConnectionId();
55
56 // A generic predictable connection ID suited for testing, generated from a
57 // given number, such as an index.
58 QuicConnectionId TestConnectionId(uint64_t connection_number);
59
60 // A generic predictable connection ID suited for testing, generated from a
61 // given number, such as an index. Guaranteed to be 9 bytes long.
62 QuicConnectionId TestConnectionIdNineBytesLong(uint64_t connection_number);
63
64 // Extracts the connection number passed to TestConnectionId().
65 uint64_t TestConnectionIdToUInt64(QuicConnectionId connection_id);
66
67 enum : uint16_t { kTestPort = 12345 };
68 enum : uint32_t {
69 kMaxDatagramFrameSizeForTest = 1333,
70 kMaxPacketSizeForTest = 9001,
71 kInitialStreamFlowControlWindowForTest = 1024 * 1024, // 1 MB
72 kInitialSessionFlowControlWindowForTest = 1536 * 1024, // 1.5 MB
73 };
74
75 enum : uint64_t {
76 kAckDelayExponentForTest = 10,
77 kMaxAckDelayForTest = 51, // ms
78 kActiveConnectionIdLimitForTest = 52,
79 kMinAckDelayUsForTest = 1000
80 };
81
82 // Create an arbitrary stateless reset token, same across multiple calls.
83 std::vector<uint8_t> CreateStatelessResetTokenForTest();
84
85 // A hostname useful for testing, returns "test.example.org".
86 std::string TestHostname();
87
88 // A server ID useful for testing, returns test.example.org:12345.
89 QuicServerId TestServerId();
90
91 // Returns the test peer IP address.
92 QuicIpAddress TestPeerIPAddress();
93
94 // Upper limit on versions we support.
95 ParsedQuicVersion QuicVersionMax();
96
97 // Lower limit on versions we support.
98 ParsedQuicVersion QuicVersionMin();
99
100 // Disables all flags that enable QUIC versions that use TLS.
101 // This is only meant as a temporary measure to prevent some broken tests
102 // from running with TLS.
103 void DisableQuicVersionsWithTls();
104
105 // Create an encrypted packet for testing.
106 // If versions == nullptr, uses &AllSupportedVersions().
107 // Note that the packet is encrypted with NullEncrypter, so to decrypt the
108 // constructed packet, the framer must be set to use NullDecrypter.
109 QuicEncryptedPacket* ConstructEncryptedPacket(
110 QuicConnectionId destination_connection_id,
111 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
112 uint64_t packet_number, const std::string& data, bool full_padding,
113 QuicConnectionIdIncluded destination_connection_id_included,
114 QuicConnectionIdIncluded source_connection_id_included,
115 QuicPacketNumberLength packet_number_length,
116 ParsedQuicVersionVector* versions, Perspective perspective);
117
118 QuicEncryptedPacket* ConstructEncryptedPacket(
119 QuicConnectionId destination_connection_id,
120 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
121 uint64_t packet_number, const std::string& data, bool full_padding,
122 QuicConnectionIdIncluded destination_connection_id_included,
123 QuicConnectionIdIncluded source_connection_id_included,
124 QuicPacketNumberLength packet_number_length,
125 ParsedQuicVersionVector* versions);
126
127 // Create an encrypted packet for testing.
128 // If versions == nullptr, uses &AllSupportedVersions().
129 // Note that the packet is encrypted with NullEncrypter, so to decrypt the
130 // constructed packet, the framer must be set to use NullDecrypter.
131 QuicEncryptedPacket* ConstructEncryptedPacket(
132 QuicConnectionId destination_connection_id,
133 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
134 uint64_t packet_number, const std::string& data,
135 QuicConnectionIdIncluded destination_connection_id_included,
136 QuicConnectionIdIncluded source_connection_id_included,
137 QuicPacketNumberLength packet_number_length,
138 ParsedQuicVersionVector* versions);
139
140 // This form assumes |versions| == nullptr.
141 QuicEncryptedPacket* ConstructEncryptedPacket(
142 QuicConnectionId destination_connection_id,
143 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
144 uint64_t packet_number, const std::string& data,
145 QuicConnectionIdIncluded destination_connection_id_included,
146 QuicConnectionIdIncluded source_connection_id_included,
147 QuicPacketNumberLength packet_number_length);
148
149 // This form assumes |connection_id_length| == PACKET_8BYTE_CONNECTION_ID,
150 // |packet_number_length| == PACKET_4BYTE_PACKET_NUMBER and
151 // |versions| == nullptr.
152 QuicEncryptedPacket* ConstructEncryptedPacket(
153 QuicConnectionId destination_connection_id,
154 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
155 uint64_t packet_number, const std::string& data);
156
157 // Creates a client-to-server ZERO-RTT packet that will fail to decrypt.
158 std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
159 const ParsedQuicVersion& version,
160 const QuicConnectionId& server_connection_id);
161
162 // Constructs a received packet for testing. The caller must take ownership
163 // of the returned pointer.
164 QuicReceivedPacket* ConstructReceivedPacket(
165 const QuicEncryptedPacket& encrypted_packet, QuicTime receipt_time);
166
167 // Create an encrypted packet for testing whose data portion erroneous.
168 // The specific way the data portion is erroneous is not specified, but
169 // it is an error that QuicFramer detects.
170 // Note that the packet is encrypted with NullEncrypter, so to decrypt the
171 // constructed packet, the framer must be set to use NullDecrypter.
172 QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
173 QuicConnectionId destination_connection_id,
174 QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
175 uint64_t packet_number, const std::string& data,
176 QuicConnectionIdIncluded destination_connection_id_included,
177 QuicConnectionIdIncluded source_connection_id_included,
178 QuicPacketNumberLength packet_number_length, ParsedQuicVersion version,
179 Perspective perspective);
180
181 // Returns QuicConfig set to default values.
182 QuicConfig DefaultQuicConfig();
183
184 ParsedQuicVersionVector SupportedVersions(ParsedQuicVersion version);
185
186 struct QuicAckBlock {
187 QuicPacketNumber start; // Included
188 QuicPacketNumber limit; // Excluded
189 };
190
191 // Testing convenience method to construct a QuicAckFrame with arbitrary ack
192 // blocks. Each block is given by a (closed-open) range of packet numbers. e.g.:
193 // InitAckFrame({{1, 10}})
194 // => 1 ack block acking packet numbers 1 to 9.
195 //
196 // InitAckFrame({{1, 2}, {3, 4}})
197 // => 2 ack blocks acking packet 1 and 3. Packet 2 is missing.
198 QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks);
199
200 // Testing convenience method to construct a QuicAckFrame with 1 ack block which
201 // covers packet number range [1, |largest_acked| + 1).
202 // Equivalent to InitAckFrame({{1, largest_acked + 1}})
203 QuicAckFrame InitAckFrame(uint64_t largest_acked);
204 QuicAckFrame InitAckFrame(QuicPacketNumber largest_acked);
205
206 // Testing convenience method to construct a QuicAckFrame with |num_ack_blocks|
207 // ack blocks of width 1 packet, starting from |least_unacked| + 2.
208 QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks,
209 uint64_t least_unacked);
210
211 // Testing convenice method to construct a QuicAckFrame with |largest_acked|,
212 // ack blocks of width 1 packet and |gap_size|.
213 QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size, size_t max_num_gaps,
214 uint64_t largest_acked);
215
216 // Returns the encryption level that corresponds to the header type in
217 // |header|. If the header is for GOOGLE_QUIC_PACKET instead of an
218 // IETF-invariants packet, this function returns ENCRYPTION_INITIAL.
219 EncryptionLevel HeaderToEncryptionLevel(const QuicPacketHeader& header);
220
221 // Returns a QuicPacket that is owned by the caller, and
222 // is populated with the fields in |header| and |frames|, or is nullptr if the
223 // packet could not be created.
224 std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
225 QuicFramer* framer, const QuicPacketHeader& header,
226 const QuicFrames& frames);
227 // Returns a QuicPacket that is owned by the caller, and of size |packet_size|.
228 std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
229 QuicFramer* framer, const QuicPacketHeader& header,
230 const QuicFrames& frames, size_t packet_size);
231
232 // Compute SHA-1 hash of the supplied std::string.
233 std::string Sha1Hash(absl::string_view data);
234
235 // Delete |frame| and return true.
236 bool ClearControlFrame(const QuicFrame& frame);
237 bool ClearControlFrameWithTransmissionType(const QuicFrame& frame,
238 TransmissionType type);
239
240 // Simple random number generator used to compute random numbers suitable
241 // for pseudo-randomly dropping packets in tests.
242 class SimpleRandom : public QuicRandom {
243 public:
SimpleRandom()244 SimpleRandom() { set_seed(0); }
245 SimpleRandom(const SimpleRandom&) = delete;
246 SimpleRandom& operator=(const SimpleRandom&) = delete;
~SimpleRandom()247 ~SimpleRandom() override {}
248
249 // Generates |len| random bytes in the |data| buffer.
250 void RandBytes(void* data, size_t len) override;
251 // Returns a random number in the range [0, kuint64max].
252 uint64_t RandUint64() override;
253
254 // InsecureRandBytes behaves equivalently to RandBytes.
255 void InsecureRandBytes(void* data, size_t len) override;
256 // InsecureRandUint64 behaves equivalently to RandUint64.
257 uint64_t InsecureRandUint64() override;
258
259 void set_seed(uint64_t seed);
260
261 private:
262 uint8_t buffer_[4096];
263 size_t buffer_offset_ = 0;
264 uint8_t key_[32];
265
266 void FillBuffer();
267 };
268
269 class MockFramerVisitor : public QuicFramerVisitorInterface {
270 public:
271 MockFramerVisitor();
272 MockFramerVisitor(const MockFramerVisitor&) = delete;
273 MockFramerVisitor& operator=(const MockFramerVisitor&) = delete;
274 ~MockFramerVisitor() override;
275
276 MOCK_METHOD(void, OnError, (QuicFramer*), (override));
277 // The constructor sets this up to return false by default.
278 MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
279 (override));
280 MOCK_METHOD(void, OnPacket, (), (override));
281 MOCK_METHOD(void, OnVersionNegotiationPacket,
282 (const QuicVersionNegotiationPacket& packet), (override));
283 MOCK_METHOD(void, OnRetryPacket,
284 (QuicConnectionId original_connection_id,
285 QuicConnectionId new_connection_id,
286 absl::string_view retry_token,
287 absl::string_view retry_integrity_tag,
288 absl::string_view retry_without_tag),
289 (override));
290 // The constructor sets this up to return true by default.
291 MOCK_METHOD(bool, OnUnauthenticatedHeader, (const QuicPacketHeader& header),
292 (override));
293 // The constructor sets this up to return true by default.
294 MOCK_METHOD(bool, OnUnauthenticatedPublicHeader,
295 (const QuicPacketHeader& header), (override));
296 MOCK_METHOD(void, OnDecryptedPacket, (size_t length, EncryptionLevel level),
297 (override));
298 MOCK_METHOD(bool, OnPacketHeader, (const QuicPacketHeader& header),
299 (override));
300 MOCK_METHOD(void, OnCoalescedPacket, (const QuicEncryptedPacket& packet),
301 (override));
302 MOCK_METHOD(void, OnUndecryptablePacket,
303 (const QuicEncryptedPacket& packet,
304 EncryptionLevel decryption_level, bool has_decryption_key),
305 (override));
306 MOCK_METHOD(bool, OnStreamFrame, (const QuicStreamFrame& frame), (override));
307 MOCK_METHOD(bool, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
308 MOCK_METHOD(bool, OnAckFrameStart, (QuicPacketNumber, QuicTime::Delta),
309 (override));
310 MOCK_METHOD(bool, OnAckRange, (QuicPacketNumber, QuicPacketNumber),
311 (override));
312 MOCK_METHOD(bool, OnAckTimestamp, (QuicPacketNumber, QuicTime), (override));
313 MOCK_METHOD(bool, OnAckFrameEnd,
314 (QuicPacketNumber, const std::optional<QuicEcnCounts>&),
315 (override));
316 MOCK_METHOD(bool, OnStopWaitingFrame, (const QuicStopWaitingFrame& frame),
317 (override));
318 MOCK_METHOD(bool, OnPaddingFrame, (const QuicPaddingFrame& frame),
319 (override));
320 MOCK_METHOD(bool, OnPingFrame, (const QuicPingFrame& frame), (override));
321 MOCK_METHOD(bool, OnRstStreamFrame, (const QuicRstStreamFrame& frame),
322 (override));
323 MOCK_METHOD(bool, OnConnectionCloseFrame,
324 (const QuicConnectionCloseFrame& frame), (override));
325 MOCK_METHOD(bool, OnNewConnectionIdFrame,
326 (const QuicNewConnectionIdFrame& frame), (override));
327 MOCK_METHOD(bool, OnRetireConnectionIdFrame,
328 (const QuicRetireConnectionIdFrame& frame), (override));
329 MOCK_METHOD(bool, OnNewTokenFrame, (const QuicNewTokenFrame& frame),
330 (override));
331 MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
332 (override));
333 MOCK_METHOD(bool, OnPathChallengeFrame, (const QuicPathChallengeFrame& frame),
334 (override));
335 MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame& frame),
336 (override));
337 MOCK_METHOD(bool, OnGoAwayFrame, (const QuicGoAwayFrame& frame), (override));
338 MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
339 (override));
340 MOCK_METHOD(bool, OnStreamsBlockedFrame,
341 (const QuicStreamsBlockedFrame& frame), (override));
342 MOCK_METHOD(bool, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
343 (override));
344 MOCK_METHOD(bool, OnBlockedFrame, (const QuicBlockedFrame& frame),
345 (override));
346 MOCK_METHOD(bool, OnMessageFrame, (const QuicMessageFrame& frame),
347 (override));
348 MOCK_METHOD(bool, OnHandshakeDoneFrame, (const QuicHandshakeDoneFrame& frame),
349 (override));
350 MOCK_METHOD(bool, OnAckFrequencyFrame, (const QuicAckFrequencyFrame& frame),
351 (override));
352 MOCK_METHOD(void, OnPacketComplete, (), (override));
353 MOCK_METHOD(bool, IsValidStatelessResetToken, (const StatelessResetToken&),
354 (const, override));
355 MOCK_METHOD(void, OnAuthenticatedIetfStatelessResetPacket,
356 (const QuicIetfStatelessResetPacket&), (override));
357 MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
358 MOCK_METHOD(void, OnDecryptedFirstPacketInKeyPhase, (), (override));
359 MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
360 AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
361 MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
362 (override));
363 };
364
365 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
366 public:
NoOpFramerVisitor()367 NoOpFramerVisitor() {}
368 NoOpFramerVisitor(const NoOpFramerVisitor&) = delete;
369 NoOpFramerVisitor& operator=(const NoOpFramerVisitor&) = delete;
370
OnError(QuicFramer *)371 void OnError(QuicFramer* /*framer*/) override {}
OnPacket()372 void OnPacket() override {}
OnVersionNegotiationPacket(const QuicVersionNegotiationPacket &)373 void OnVersionNegotiationPacket(
374 const QuicVersionNegotiationPacket& /*packet*/) override {}
OnRetryPacket(QuicConnectionId,QuicConnectionId,absl::string_view,absl::string_view,absl::string_view)375 void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
376 QuicConnectionId /*new_connection_id*/,
377 absl::string_view /*retry_token*/,
378 absl::string_view /*retry_integrity_tag*/,
379 absl::string_view /*retry_without_tag*/) override {}
380 bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
381 bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
382 bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
OnDecryptedPacket(size_t,EncryptionLevel)383 void OnDecryptedPacket(size_t /*length*/,
384 EncryptionLevel /*level*/) override {}
385 bool OnPacketHeader(const QuicPacketHeader& header) override;
386 void OnCoalescedPacket(const QuicEncryptedPacket& packet) override;
387 void OnUndecryptablePacket(const QuicEncryptedPacket& packet,
388 EncryptionLevel decryption_level,
389 bool has_decryption_key) override;
390 bool OnStreamFrame(const QuicStreamFrame& frame) override;
391 bool OnCryptoFrame(const QuicCryptoFrame& frame) override;
392 bool OnAckFrameStart(QuicPacketNumber largest_acked,
393 QuicTime::Delta ack_delay_time) override;
394 bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override;
395 bool OnAckTimestamp(QuicPacketNumber packet_number,
396 QuicTime timestamp) override;
397 bool OnAckFrameEnd(QuicPacketNumber start,
398 const std::optional<QuicEcnCounts>& ecn_counts) override;
399 bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
400 bool OnPaddingFrame(const QuicPaddingFrame& frame) override;
401 bool OnPingFrame(const QuicPingFrame& frame) override;
402 bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
403 bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override;
404 bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override;
405 bool OnRetireConnectionIdFrame(
406 const QuicRetireConnectionIdFrame& frame) override;
407 bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override;
408 bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override;
409 bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override;
410 bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override;
411 bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
412 bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override;
413 bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override;
414 bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
415 bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
416 bool OnMessageFrame(const QuicMessageFrame& frame) override;
417 bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override;
418 bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override;
OnPacketComplete()419 void OnPacketComplete() override {}
420 bool IsValidStatelessResetToken(
421 const StatelessResetToken& token) const override;
OnAuthenticatedIetfStatelessResetPacket(const QuicIetfStatelessResetPacket &)422 void OnAuthenticatedIetfStatelessResetPacket(
423 const QuicIetfStatelessResetPacket& /*packet*/) override {}
OnKeyUpdate(KeyUpdateReason)424 void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
OnDecryptedFirstPacketInKeyPhase()425 void OnDecryptedFirstPacketInKeyPhase() override {}
AdvanceKeysAndCreateCurrentOneRttDecrypter()426 std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
427 override {
428 return nullptr;
429 }
CreateCurrentOneRttEncrypter()430 std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
431 return nullptr;
432 }
433 };
434
435 class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
436 public:
437 MockQuicConnectionVisitor();
438 MockQuicConnectionVisitor(const MockQuicConnectionVisitor&) = delete;
439 MockQuicConnectionVisitor& operator=(const MockQuicConnectionVisitor&) =
440 delete;
441 ~MockQuicConnectionVisitor() override;
442
443 MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
444 MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
445 MOCK_METHOD(void, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
446 (override));
447 MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame& frame),
448 (override));
449 MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
450 MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
451 MOCK_METHOD(void, OnMessageReceived, (absl::string_view message), (override));
452 MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
453 MOCK_METHOD(void, OnNewTokenReceived, (absl::string_view token), (override));
454 MOCK_METHOD(void, OnConnectionClosed,
455 (const QuicConnectionCloseFrame& frame,
456 ConnectionCloseSource source),
457 (override));
458 MOCK_METHOD(void, OnWriteBlocked, (), (override));
459 MOCK_METHOD(void, OnCanWrite, (), (override));
460 MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
461 MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
462 (override));
463 MOCK_METHOD(void, OnPathDegrading, (), (override));
464 MOCK_METHOD(void, OnForwardProgressMadeAfterPathDegrading, (), (override));
465 MOCK_METHOD(bool, WillingAndAbleToWrite, (), (const, override));
466 MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
467 MOCK_METHOD(std::string, GetStreamsInfoForLogging, (), (const, override));
468 MOCK_METHOD(void, OnSuccessfulVersionNegotiation,
469 (const ParsedQuicVersion& version), (override));
470 MOCK_METHOD(void, OnPacketReceived,
471 (const QuicSocketAddress& self_address,
472 const QuicSocketAddress& peer_address,
473 bool is_connectivity_probe),
474 (override));
475 MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
476 MOCK_METHOD(void, SendAckFrequency, (const QuicAckFrequencyFrame& frame),
477 (override));
478 MOCK_METHOD(void, SendNewConnectionId,
479 (const QuicNewConnectionIdFrame& frame), (override));
480 MOCK_METHOD(void, SendRetireConnectionId, (uint64_t sequence_number),
481 (override));
482 MOCK_METHOD(bool, MaybeReserveConnectionId,
483 (const QuicConnectionId& server_connection_id), (override));
484 MOCK_METHOD(void, OnServerConnectionIdRetired,
485 (const QuicConnectionId& server_connection_id), (override));
486 MOCK_METHOD(bool, AllowSelfAddressChange, (), (const, override));
487 MOCK_METHOD(HandshakeState, GetHandshakeState, (), (const, override));
488 MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
489 (override));
490 MOCK_METHOD(bool, OnStreamsBlockedFrame,
491 (const QuicStreamsBlockedFrame& frame), (override));
492 MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
493 (override));
494 MOCK_METHOD(void, OnPacketDecrypted, (EncryptionLevel), (override));
495 MOCK_METHOD(void, OnOneRttPacketAcknowledged, (), (override));
496 MOCK_METHOD(void, OnHandshakePacketSent, (), (override));
497 MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
498 MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
499 AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
500 MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
501 (override));
502 MOCK_METHOD(void, BeforeConnectionCloseSent, (), (override));
503 MOCK_METHOD(bool, ValidateToken, (absl::string_view), (override));
504 MOCK_METHOD(bool, MaybeSendAddressToken, (), (override));
505 MOCK_METHOD(void, CreateContextForMultiPortPath,
506 (std::unique_ptr<MultiPortPathContextObserver>), (override));
507 MOCK_METHOD(void, MigrateToMultiPortPath,
508 (std::unique_ptr<QuicPathValidationContext>), (override));
509 MOCK_METHOD(void, OnServerPreferredAddressAvailable,
510 (const QuicSocketAddress&), (override));
511 MOCK_METHOD(void, MaybeBundleOpportunistically, (), (override));
512 MOCK_METHOD(QuicByteCount, GetFlowControlSendWindowSize, (QuicStreamId),
513 (override));
514 };
515
516 class MockQuicConnectionHelper : public QuicConnectionHelperInterface {
517 public:
518 MockQuicConnectionHelper();
519 MockQuicConnectionHelper(const MockQuicConnectionHelper&) = delete;
520 MockQuicConnectionHelper& operator=(const MockQuicConnectionHelper&) = delete;
521 ~MockQuicConnectionHelper() override;
522 const MockClock* GetClock() const override;
523 MockClock* GetClock();
524 QuicRandom* GetRandomGenerator() override;
525 quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
526 void AdvanceTime(QuicTime::Delta delta);
527
528 private:
529 MockClock clock_;
530 testing::NiceMock<MockRandom> random_generator_;
531 quiche::SimpleBufferAllocator buffer_allocator_;
532 };
533
534 class MockAlarmFactory : public QuicAlarmFactory {
535 public:
536 QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
537 QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
538 QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
539 QuicConnectionArena* arena) override;
540
541 // No-op alarm implementation
542 class TestAlarm : public QuicAlarm {
543 public:
TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)544 explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
545 : QuicAlarm(std::move(delegate)) {}
546
SetImpl()547 void SetImpl() override {}
CancelImpl()548 void CancelImpl() override {}
549
550 using QuicAlarm::Fire;
551 };
552
FireAlarm(QuicAlarm * alarm)553 void FireAlarm(QuicAlarm* alarm) {
554 reinterpret_cast<TestAlarm*>(alarm)->Fire();
555 }
556 };
557
558 class TestAlarmFactory : public QuicAlarmFactory {
559 public:
560 class TestAlarm : public QuicAlarm {
561 public:
TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)562 explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
563 : QuicAlarm(std::move(delegate)) {}
564
SetImpl()565 void SetImpl() override {}
CancelImpl()566 void CancelImpl() override {}
567 using QuicAlarm::Fire;
568 };
569
TestAlarmFactory()570 TestAlarmFactory() {}
571 TestAlarmFactory(const TestAlarmFactory&) = delete;
572 TestAlarmFactory& operator=(const TestAlarmFactory&) = delete;
573
CreateAlarm(QuicAlarm::Delegate * delegate)574 QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
575 return new TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
576 }
577
CreateAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,QuicConnectionArena * arena)578 QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
579 QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
580 QuicConnectionArena* arena) override {
581 return arena->New<TestAlarm>(std::move(delegate));
582 }
583 };
584
585 class MockQuicConnection : public QuicConnection {
586 public:
587 // Uses a ConnectionId of 42 and 127.0.0.1:123.
588 MockQuicConnection(QuicConnectionHelperInterface* helper,
589 QuicAlarmFactory* alarm_factory, Perspective perspective);
590
591 // Uses a ConnectionId of 42.
592 MockQuicConnection(QuicSocketAddress address,
593 QuicConnectionHelperInterface* helper,
594 QuicAlarmFactory* alarm_factory, Perspective perspective);
595
596 // Uses 127.0.0.1:123.
597 MockQuicConnection(QuicConnectionId connection_id,
598 QuicConnectionHelperInterface* helper,
599 QuicAlarmFactory* alarm_factory, Perspective perspective);
600
601 // Uses a ConnectionId of 42, and 127.0.0.1:123.
602 MockQuicConnection(QuicConnectionHelperInterface* helper,
603 QuicAlarmFactory* alarm_factory, Perspective perspective,
604 const ParsedQuicVersionVector& supported_versions);
605
606 MockQuicConnection(QuicConnectionId connection_id, QuicSocketAddress address,
607 QuicConnectionHelperInterface* helper,
608 QuicAlarmFactory* alarm_factory, Perspective perspective,
609 const ParsedQuicVersionVector& supported_versions);
610 MockQuicConnection(const MockQuicConnection&) = delete;
611 MockQuicConnection& operator=(const MockQuicConnection&) = delete;
612
613 ~MockQuicConnection() override;
614
615 // If the constructor that uses a QuicConnectionHelperInterface has been used
616 // then this method will advance the time of the MockClock.
617 void AdvanceTime(QuicTime::Delta delta);
618
619 MOCK_METHOD(void, ProcessUdpPacket,
620 (const QuicSocketAddress& self_address,
621 const QuicSocketAddress& peer_address,
622 const QuicReceivedPacket& packet),
623 (override));
624 MOCK_METHOD(void, CloseConnection,
625 (QuicErrorCode error, const std::string& details,
626 ConnectionCloseBehavior connection_close_behavior),
627 (override));
628 MOCK_METHOD(void, CloseConnection,
629 (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
630 const std::string& details,
631 ConnectionCloseBehavior connection_close_behavior),
632 (override));
633 MOCK_METHOD(void, SendConnectionClosePacket,
634 (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
635 const std::string& details),
636 (override));
637 MOCK_METHOD(void, OnCanWrite, (), (override));
638 MOCK_METHOD(bool, SendConnectivityProbingPacket,
639 (QuicPacketWriter*, const QuicSocketAddress& peer_address),
640 (override));
641 MOCK_METHOD(void, MaybeProbeMultiPortPath, (), (override));
642
643 MOCK_METHOD(void, OnSendConnectionState, (const CachedNetworkParameters&),
644 (override));
645 MOCK_METHOD(void, ResumeConnectionState,
646 (const CachedNetworkParameters&, bool), (override));
647 MOCK_METHOD(void, SetMaxPacingRate, (QuicBandwidth), (override));
648
649 MOCK_METHOD(void, OnStreamReset, (QuicStreamId, QuicRstStreamErrorCode),
650 (override));
651 MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
652 MOCK_METHOD(MessageStatus, SendMessage,
653 (QuicMessageId, absl::Span<quiche::QuicheMemSlice>, bool),
654 (override));
655 MOCK_METHOD(bool, SendPathChallenge,
656 (const QuicPathFrameBuffer&, const QuicSocketAddress&,
657 const QuicSocketAddress&, const QuicSocketAddress&,
658 QuicPacketWriter*),
659 (override));
660
661 MOCK_METHOD(void, OnError, (QuicFramer*), (override));
QuicConnection_OnError(QuicFramer * framer)662 void QuicConnection_OnError(QuicFramer* framer) {
663 QuicConnection::OnError(framer);
664 }
665
ReallyOnCanWrite()666 void ReallyOnCanWrite() { QuicConnection::OnCanWrite(); }
667
ReallyCloseConnection(QuicErrorCode error,const std::string & details,ConnectionCloseBehavior connection_close_behavior)668 void ReallyCloseConnection(
669 QuicErrorCode error, const std::string& details,
670 ConnectionCloseBehavior connection_close_behavior) {
671 // Call the 4-param method directly instead of the 3-param method, so that
672 // it doesn't invoke the virtual 4-param method causing the mock 4-param
673 // method to trigger.
674 QuicConnection::CloseConnection(error, NO_IETF_QUIC_ERROR, details,
675 connection_close_behavior);
676 }
677
ReallyCloseConnection4(QuicErrorCode error,QuicIetfTransportErrorCodes ietf_error,const std::string & details,ConnectionCloseBehavior connection_close_behavior)678 void ReallyCloseConnection4(
679 QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
680 const std::string& details,
681 ConnectionCloseBehavior connection_close_behavior) {
682 QuicConnection::CloseConnection(error, ietf_error, details,
683 connection_close_behavior);
684 }
685
ReallySendConnectionClosePacket(QuicErrorCode error,QuicIetfTransportErrorCodes ietf_error,const std::string & details)686 void ReallySendConnectionClosePacket(QuicErrorCode error,
687 QuicIetfTransportErrorCodes ietf_error,
688 const std::string& details) {
689 QuicConnection::SendConnectionClosePacket(error, ietf_error, details);
690 }
691
ReallyProcessUdpPacket(const QuicSocketAddress & self_address,const QuicSocketAddress & peer_address,const QuicReceivedPacket & packet)692 void ReallyProcessUdpPacket(const QuicSocketAddress& self_address,
693 const QuicSocketAddress& peer_address,
694 const QuicReceivedPacket& packet) {
695 QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
696 }
697
698 bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
OnIdleNetworkDetected()699 void OnIdleNetworkDetected() override {}
700
ReallySendControlFrame(const QuicFrame & frame)701 bool ReallySendControlFrame(const QuicFrame& frame) {
702 return QuicConnection::SendControlFrame(frame);
703 }
704
ReallySendConnectivityProbingPacket(QuicPacketWriter * probing_writer,const QuicSocketAddress & peer_address)705 bool ReallySendConnectivityProbingPacket(
706 QuicPacketWriter* probing_writer, const QuicSocketAddress& peer_address) {
707 return QuicConnection::SendConnectivityProbingPacket(probing_writer,
708 peer_address);
709 }
710
ReallyOnPathResponseFrame(const QuicPathResponseFrame & frame)711 bool ReallyOnPathResponseFrame(const QuicPathResponseFrame& frame) {
712 return QuicConnection::OnPathResponseFrame(frame);
713 }
714
715 MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame&),
716 (override));
717 MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
718 (override));
719 MOCK_METHOD(size_t, SendCryptoData,
720 (EncryptionLevel, size_t, QuicStreamOffset), (override));
QuicConnection_SendCryptoData(EncryptionLevel level,size_t write_length,QuicStreamOffset offset)721 size_t QuicConnection_SendCryptoData(EncryptionLevel level,
722 size_t write_length,
723 QuicStreamOffset offset) {
724 return QuicConnection::SendCryptoData(level, write_length, offset);
725 }
726
connection_id_generator()727 MockConnectionIdGenerator& connection_id_generator() {
728 return connection_id_generator_;
729 }
730
731 private:
732 // It would be more correct to pass the generator as an argument to the
733 // constructor, particularly in dispatcher tests that keep their own
734 // reference to a generator. But there are many, many instances of derived
735 // test classes that would have to declare a generator. As this object is
736 // public, it is straightforward for the caller to use it as an argument to
737 // EXPECT_CALL.
738 MockConnectionIdGenerator connection_id_generator_;
739 };
740
741 // Helper that allows retrieving and clearing queued packets.
742 class PacketProvider {
743 public:
744 virtual ~PacketProvider() = default;
745
746 virtual std::vector<const QuicEncryptedPacket*> GetPackets() const = 0;
747 virtual void ClearPackets() = 0;
748 };
749
750 class PacketSavingConnection : public MockQuicConnection,
751 public PacketProvider {
752 public:
753 PacketSavingConnection(MockQuicConnectionHelper* helper,
754 QuicAlarmFactory* alarm_factory,
755 Perspective perspective);
756
757 PacketSavingConnection(MockQuicConnectionHelper* helper,
758 QuicAlarmFactory* alarm_factory,
759 Perspective perspective,
760 const ParsedQuicVersionVector& supported_versions);
761 PacketSavingConnection(const PacketSavingConnection&) = delete;
762 PacketSavingConnection& operator=(const PacketSavingConnection&) = delete;
763
764 ~PacketSavingConnection() override;
765
766 SerializedPacketFate GetSerializedPacketFate(
767 bool is_mtu_discovery, EncryptionLevel encryption_level) override;
768
769 void SendOrQueuePacket(SerializedPacket packet) override;
770
771 MOCK_METHOD(void, OnPacketSent, (EncryptionLevel, TransmissionType));
772
773 // PacketProvider:
774 std::vector<const QuicEncryptedPacket*> GetPackets() const override;
775 void ClearPackets() override;
776
777 std::vector<std::unique_ptr<QuicEncryptedPacket>> encrypted_packets_;
778
779 private:
780 size_t num_cleared_packets_ = 0;
781 MockQuicConnectionHelper* mock_helper_ = nullptr;
782 };
783
784 class MockQuicSession : public QuicSession {
785 public:
786 // Takes ownership of |connection|.
787 MockQuicSession(QuicConnection* connection, bool create_mock_crypto_stream);
788
789 // Takes ownership of |connection|.
790 explicit MockQuicSession(QuicConnection* connection);
791 MockQuicSession(const MockQuicSession&) = delete;
792 MockQuicSession& operator=(const MockQuicSession&) = delete;
793 ~MockQuicSession() override;
794
795 QuicCryptoStream* GetMutableCryptoStream() override;
796 const QuicCryptoStream* GetCryptoStream() const override;
797 void SetCryptoStream(QuicCryptoStream* crypto_stream);
798
799 MOCK_METHOD(void, OnConnectionClosed,
800 (const QuicConnectionCloseFrame& frame,
801 ConnectionCloseSource source),
802 (override));
803 MOCK_METHOD(QuicStream*, CreateIncomingStream, (QuicStreamId id), (override));
804 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
805 (override));
806 MOCK_METHOD(QuicConsumedData, WritevData,
807 (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
808 StreamSendingState state, TransmissionType type,
809 EncryptionLevel level),
810 (override));
811 MOCK_METHOD(bool, WriteControlFrame,
812 (const QuicFrame& frame, TransmissionType type), (override));
813 MOCK_METHOD(void, MaybeSendRstStreamFrame,
814 (QuicStreamId stream_id, QuicResetStreamError error,
815 QuicStreamOffset bytes_written),
816 (override));
817 MOCK_METHOD(void, MaybeSendStopSendingFrame,
818 (QuicStreamId stream_id, QuicResetStreamError error), (override));
819 MOCK_METHOD(void, SendBlocked,
820 (QuicStreamId stream_id, QuicStreamOffset offset), (override));
821
822 MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
823 MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
824 MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
825 (const std::vector<absl::string_view>&), (const, override));
826 MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
827
828 using QuicSession::ActivateStream;
829
830 // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
831 // if set) has been consumed.
832 QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
833 QuicStreamOffset offset,
834 StreamSendingState state, TransmissionType type,
835 std::optional<EncryptionLevel> level);
836
ReallyMaybeSendRstStreamFrame(QuicStreamId id,QuicRstStreamErrorCode error,QuicStreamOffset bytes_written)837 void ReallyMaybeSendRstStreamFrame(QuicStreamId id,
838 QuicRstStreamErrorCode error,
839 QuicStreamOffset bytes_written) {
840 QuicSession::MaybeSendRstStreamFrame(
841 id, QuicResetStreamError::FromInternal(error), bytes_written);
842 }
843
844 private:
845 std::unique_ptr<QuicCryptoStream> crypto_stream_;
846 };
847
848 class MockQuicCryptoStream : public QuicCryptoStream {
849 public:
850 explicit MockQuicCryptoStream(QuicSession* session);
851
852 ~MockQuicCryptoStream() override;
853
854 MOCK_METHOD(bool, encryption_established, (), (const));
855
856 ssl_early_data_reason_t EarlyDataReason() const override;
857 bool one_rtt_keys_available() const override;
858 const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
859 const override;
860 CryptoMessageParser* crypto_message_parser() override;
OnPacketDecrypted(EncryptionLevel)861 void OnPacketDecrypted(EncryptionLevel /*level*/) override {}
OnOneRttPacketAcknowledged()862 void OnOneRttPacketAcknowledged() override {}
OnHandshakePacketSent()863 void OnHandshakePacketSent() override {}
OnHandshakeDoneReceived()864 void OnHandshakeDoneReceived() override {}
OnNewTokenReceived(absl::string_view)865 void OnNewTokenReceived(absl::string_view /*token*/) override {}
GetAddressToken(const CachedNetworkParameters *)866 std::string GetAddressToken(
867 const CachedNetworkParameters* /*cached_network_parameters*/)
868 const override {
869 return "";
870 }
ValidateAddressToken(absl::string_view)871 bool ValidateAddressToken(absl::string_view /*token*/) const override {
872 return true;
873 }
PreviousCachedNetworkParams()874 const CachedNetworkParameters* PreviousCachedNetworkParams() const override {
875 return nullptr;
876 }
SetPreviousCachedNetworkParams(CachedNetworkParameters)877 void SetPreviousCachedNetworkParams(
878 CachedNetworkParameters /*cached_network_params*/) override {}
OnConnectionClosed(QuicErrorCode,ConnectionCloseSource)879 void OnConnectionClosed(QuicErrorCode /*error*/,
880 ConnectionCloseSource /*source*/) override {}
GetHandshakeState()881 HandshakeState GetHandshakeState() const override { return HANDSHAKE_START; }
SetServerApplicationStateForResumption(std::unique_ptr<ApplicationState>)882 void SetServerApplicationStateForResumption(
883 std::unique_ptr<ApplicationState> /*application_state*/) override {}
AdvanceKeysAndCreateCurrentOneRttDecrypter()884 std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
885 override {
886 return nullptr;
887 }
CreateCurrentOneRttEncrypter()888 std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
889 return nullptr;
890 }
ExportKeyingMaterial(absl::string_view,absl::string_view,size_t,std::string *)891 bool ExportKeyingMaterial(absl::string_view /*label*/,
892 absl::string_view /*context*/,
893 size_t /*result_len*/,
894 std::string* /*result*/) override {
895 return false;
896 }
GetSsl()897 SSL* GetSsl() const override { return nullptr; }
IsCryptoFrameExpectedForEncryptionLevel(quic::EncryptionLevel level)898 bool IsCryptoFrameExpectedForEncryptionLevel(
899 quic::EncryptionLevel level) const override {
900 return level != ENCRYPTION_ZERO_RTT;
901 }
GetEncryptionLevelToSendCryptoDataOfSpace(PacketNumberSpace space)902 EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
903 PacketNumberSpace space) const override {
904 switch (space) {
905 case INITIAL_DATA:
906 return ENCRYPTION_INITIAL;
907 case HANDSHAKE_DATA:
908 return ENCRYPTION_HANDSHAKE;
909 case APPLICATION_DATA:
910 return ENCRYPTION_FORWARD_SECURE;
911 default:
912 QUICHE_DCHECK(false);
913 return NUM_ENCRYPTION_LEVELS;
914 }
915 }
916
917 private:
918 quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
919 CryptoFramer crypto_framer_;
920 };
921
922 class MockQuicSpdySession : public QuicSpdySession {
923 public:
924 // Takes ownership of |connection|.
925 explicit MockQuicSpdySession(QuicConnection* connection);
926 // Takes ownership of |connection|.
927 MockQuicSpdySession(QuicConnection* connection,
928 bool create_mock_crypto_stream);
929 MockQuicSpdySession(const MockQuicSpdySession&) = delete;
930 MockQuicSpdySession& operator=(const MockQuicSpdySession&) = delete;
931 ~MockQuicSpdySession() override;
932
933 QuicCryptoStream* GetMutableCryptoStream() override;
934 const QuicCryptoStream* GetCryptoStream() const override;
935 void SetCryptoStream(QuicCryptoStream* crypto_stream);
936
ReallyOnConnectionClosed(const QuicConnectionCloseFrame & frame,ConnectionCloseSource source)937 void ReallyOnConnectionClosed(const QuicConnectionCloseFrame& frame,
938 ConnectionCloseSource source) {
939 QuicSession::OnConnectionClosed(frame, source);
940 }
941
942 // From QuicSession.
943 MOCK_METHOD(void, OnConnectionClosed,
944 (const QuicConnectionCloseFrame& frame,
945 ConnectionCloseSource source),
946 (override));
947 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
948 (override));
949 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
950 (override));
951 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
952 (override));
953 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
954 (override));
955 MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
956 MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
957 MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
958 MOCK_METHOD(QuicConsumedData, WritevData,
959 (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
960 StreamSendingState state, TransmissionType type,
961 EncryptionLevel level),
962 (override));
963 MOCK_METHOD(void, MaybeSendRstStreamFrame,
964 (QuicStreamId stream_id, QuicResetStreamError error,
965 QuicStreamOffset bytes_written),
966 (override));
967 MOCK_METHOD(void, MaybeSendStopSendingFrame,
968 (QuicStreamId stream_id, QuicResetStreamError error), (override));
969 MOCK_METHOD(void, SendWindowUpdate,
970 (QuicStreamId id, QuicStreamOffset byte_offset), (override));
971 MOCK_METHOD(void, SendBlocked,
972 (QuicStreamId id, QuicStreamOffset byte_offset), (override));
973 MOCK_METHOD(void, OnStreamHeadersPriority,
974 (QuicStreamId stream_id,
975 const spdy::SpdyStreamPrecedence& precedence),
976 (override));
977 MOCK_METHOD(void, OnStreamHeaderList,
978 (QuicStreamId stream_id, bool fin, size_t frame_len,
979 const QuicHeaderList& header_list),
980 (override));
981 MOCK_METHOD(void, OnPriorityFrame,
982 (QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
983 (override));
984 MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
985
986 // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
987 // if set) has been consumed.
988 QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
989 QuicStreamOffset offset,
990 StreamSendingState state, TransmissionType type,
991 std::optional<EncryptionLevel> level);
992
993 using QuicSession::ActivateStream;
994
995 private:
996 std::unique_ptr<QuicCryptoStream> crypto_stream_;
997 };
998
999 class MockHttp3DebugVisitor : public Http3DebugVisitor {
1000 public:
1001 MOCK_METHOD(void, OnControlStreamCreated, (QuicStreamId), (override));
1002 MOCK_METHOD(void, OnQpackEncoderStreamCreated, (QuicStreamId), (override));
1003 MOCK_METHOD(void, OnQpackDecoderStreamCreated, (QuicStreamId), (override));
1004 MOCK_METHOD(void, OnPeerControlStreamCreated, (QuicStreamId), (override));
1005 MOCK_METHOD(void, OnPeerQpackEncoderStreamCreated, (QuicStreamId),
1006 (override));
1007 MOCK_METHOD(void, OnPeerQpackDecoderStreamCreated, (QuicStreamId),
1008 (override));
1009
1010 MOCK_METHOD(void, OnSettingsFrameReceivedViaAlps, (const SettingsFrame&),
1011 (override));
1012
1013 MOCK_METHOD(void, OnAcceptChFrameReceivedViaAlps, (const AcceptChFrame&),
1014 (override));
1015
1016 MOCK_METHOD(void, OnSettingsFrameReceived, (const SettingsFrame&),
1017 (override));
1018 MOCK_METHOD(void, OnGoAwayFrameReceived, (const GoAwayFrame&), (override));
1019 MOCK_METHOD(void, OnPriorityUpdateFrameReceived, (const PriorityUpdateFrame&),
1020 (override));
1021 MOCK_METHOD(void, OnAcceptChFrameReceived, (const AcceptChFrame&),
1022 (override));
1023
1024 MOCK_METHOD(void, OnDataFrameReceived, (QuicStreamId, QuicByteCount),
1025 (override));
1026 MOCK_METHOD(void, OnHeadersFrameReceived, (QuicStreamId, QuicByteCount),
1027 (override));
1028 MOCK_METHOD(void, OnHeadersDecoded, (QuicStreamId, QuicHeaderList),
1029 (override));
1030 MOCK_METHOD(void, OnUnknownFrameReceived,
1031 (QuicStreamId, uint64_t, QuicByteCount), (override));
1032
1033 MOCK_METHOD(void, OnSettingsFrameSent, (const SettingsFrame&), (override));
1034 MOCK_METHOD(void, OnGoAwayFrameSent, (QuicStreamId), (override));
1035 MOCK_METHOD(void, OnPriorityUpdateFrameSent, (const PriorityUpdateFrame&),
1036 (override));
1037
1038 MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
1039 MOCK_METHOD(void, OnHeadersFrameSent,
1040 (QuicStreamId, const spdy::Http2HeaderBlock&), (override));
1041 MOCK_METHOD(void, OnSettingsFrameResumed, (const SettingsFrame&), (override));
1042 };
1043
1044 class TestQuicSpdyServerSession : public QuicServerSessionBase {
1045 public:
1046 // Takes ownership of |connection|.
1047 TestQuicSpdyServerSession(QuicConnection* connection,
1048 const QuicConfig& config,
1049 const ParsedQuicVersionVector& supported_versions,
1050 const QuicCryptoServerConfig* crypto_config,
1051 QuicCompressedCertsCache* compressed_certs_cache);
1052 TestQuicSpdyServerSession(const TestQuicSpdyServerSession&) = delete;
1053 TestQuicSpdyServerSession& operator=(const TestQuicSpdyServerSession&) =
1054 delete;
1055 ~TestQuicSpdyServerSession() override;
1056
1057 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
1058 (override));
1059 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
1060 (override));
1061 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
1062 (override));
1063 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
1064 (override));
1065 MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
1066 (const std::vector<absl::string_view>&), (const, override));
1067 MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
1068 std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
1069 const QuicCryptoServerConfig* crypto_config,
1070 QuicCompressedCertsCache* compressed_certs_cache) override;
1071
1072 QuicCryptoServerStreamBase* GetMutableCryptoStream() override;
1073
1074 const QuicCryptoServerStreamBase* GetCryptoStream() const override;
1075
helper()1076 MockQuicCryptoServerStreamHelper* helper() { return &helper_; }
1077
GetSSLConfig()1078 QuicSSLConfig GetSSLConfig() const override {
1079 QuicSSLConfig ssl_config = QuicServerSessionBase::GetSSLConfig();
1080 if (early_data_enabled_.has_value()) {
1081 ssl_config.early_data_enabled = *early_data_enabled_;
1082 }
1083 if (client_cert_mode_.has_value()) {
1084 ssl_config.client_cert_mode = *client_cert_mode_;
1085 }
1086
1087 return ssl_config;
1088 }
1089
set_early_data_enabled(bool enabled)1090 void set_early_data_enabled(bool enabled) { early_data_enabled_ = enabled; }
1091
set_client_cert_mode(ClientCertMode mode)1092 void set_client_cert_mode(ClientCertMode mode) { client_cert_mode_ = mode; }
1093
1094 private:
1095 MockQuicSessionVisitor visitor_;
1096 MockQuicCryptoServerStreamHelper helper_;
1097 // If not nullopt, override the early_data_enabled value from base class'
1098 // ssl_config.
1099 std::optional<bool> early_data_enabled_;
1100 // If not nullopt, override the client_cert_mode value from base class'
1101 // ssl_config.
1102 std::optional<ClientCertMode> client_cert_mode_;
1103 };
1104
1105 class TestQuicSpdyClientSession : public QuicSpdyClientSessionBase {
1106 public:
1107 TestQuicSpdyClientSession(
1108 QuicConnection* connection, const QuicConfig& config,
1109 const ParsedQuicVersionVector& supported_versions,
1110 const QuicServerId& server_id, QuicCryptoClientConfig* crypto_config,
1111 std::optional<QuicSSLConfig> ssl_config = std::nullopt);
1112 TestQuicSpdyClientSession(const TestQuicSpdyClientSession&) = delete;
1113 TestQuicSpdyClientSession& operator=(const TestQuicSpdyClientSession&) =
1114 delete;
1115 ~TestQuicSpdyClientSession() override;
1116
1117 // QuicSpdyClientSessionBase
1118 MOCK_METHOD(void, OnProofValid,
1119 (const QuicCryptoClientConfig::CachedState& cached), (override));
1120 MOCK_METHOD(void, OnProofVerifyDetailsAvailable,
1121 (const ProofVerifyDetails& verify_details), (override));
1122
1123 // TestQuicSpdyClientSession
1124 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
1125 (override));
1126 MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
1127 (override));
1128 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
1129 (override));
1130 MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
1131 (override));
1132 MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
1133 MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
1134 MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
1135 MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
1136 MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
1137 MOCK_METHOD(void, OnConfigNegotiated, (), (override));
1138
1139 QuicCryptoClientStream* GetMutableCryptoStream() override;
1140 const QuicCryptoClientStream* GetCryptoStream() const override;
1141
GetSSLConfig()1142 QuicSSLConfig GetSSLConfig() const override {
1143 return ssl_config_.has_value() ? *ssl_config_
1144 : QuicSpdyClientSessionBase::GetSSLConfig();
1145 }
1146
1147 // Override to save sent crypto handshake messages.
OnCryptoHandshakeMessageSent(const CryptoHandshakeMessage & message)1148 void OnCryptoHandshakeMessageSent(
1149 const CryptoHandshakeMessage& message) override {
1150 sent_crypto_handshake_messages_.push_back(message);
1151 }
1152
sent_crypto_handshake_messages()1153 const std::vector<CryptoHandshakeMessage>& sent_crypto_handshake_messages()
1154 const {
1155 return sent_crypto_handshake_messages_;
1156 }
1157
1158 private:
1159 // Calls the parent class's OnConfigNegotiated method. Used to set the default
1160 // mock behavior for OnConfigNegotiated.
1161 void RealOnConfigNegotiated();
1162
1163 std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
1164 std::vector<CryptoHandshakeMessage> sent_crypto_handshake_messages_;
1165 std::optional<QuicSSLConfig> ssl_config_;
1166 };
1167
1168 class MockPacketWriter : public QuicPacketWriter {
1169 public:
1170 MockPacketWriter();
1171 MockPacketWriter(const MockPacketWriter&) = delete;
1172 MockPacketWriter& operator=(const MockPacketWriter&) = delete;
1173 ~MockPacketWriter() override;
1174
1175 MOCK_METHOD(WriteResult, WritePacket,
1176 (const char*, size_t buf_len, const QuicIpAddress& self_address,
1177 const QuicSocketAddress& peer_address, PerPacketOptions*,
1178 const QuicPacketWriterParams&),
1179 (override));
1180 MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
1181 MOCK_METHOD(void, SetWritable, (), (override));
1182 MOCK_METHOD(std::optional<int>, MessageTooBigErrorCode, (),
1183 (const, override));
1184 MOCK_METHOD(QuicByteCount, GetMaxPacketSize,
1185 (const QuicSocketAddress& peer_address), (const, override));
1186 MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
1187 MOCK_METHOD(bool, IsBatchMode, (), (const, override));
1188 MOCK_METHOD(bool, SupportsEcn, (), (const, override));
1189 MOCK_METHOD(QuicPacketBuffer, GetNextWriteLocation,
1190 (const QuicIpAddress& self_address,
1191 const QuicSocketAddress& peer_address),
1192 (override));
1193 MOCK_METHOD(WriteResult, Flush, (), (override));
1194 };
1195
1196 class MockSendAlgorithm : public SendAlgorithmInterface {
1197 public:
1198 MockSendAlgorithm();
1199 MockSendAlgorithm(const MockSendAlgorithm&) = delete;
1200 MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete;
1201 ~MockSendAlgorithm() override;
1202
1203 MOCK_METHOD(void, SetFromConfig,
1204 (const QuicConfig& config, Perspective perspective), (override));
1205 MOCK_METHOD(void, ApplyConnectionOptions,
1206 (const QuicTagVector& connection_options), (override));
1207 MOCK_METHOD(void, SetInitialCongestionWindowInPackets,
1208 (QuicPacketCount packets), (override));
1209 MOCK_METHOD(void, OnCongestionEvent,
1210 (bool rtt_updated, QuicByteCount bytes_in_flight,
1211 QuicTime event_time, const AckedPacketVector& acked_packets,
1212 const LostPacketVector& lost_packets, QuicPacketCount num_ect,
1213 QuicPacketCount num_ce),
1214 (override));
1215 MOCK_METHOD(void, OnPacketSent,
1216 (QuicTime, QuicByteCount, QuicPacketNumber, QuicByteCount,
1217 HasRetransmittableData),
1218 (override));
1219 MOCK_METHOD(void, OnPacketNeutered, (QuicPacketNumber), (override));
1220 MOCK_METHOD(void, OnRetransmissionTimeout, (bool), (override));
1221 MOCK_METHOD(void, OnConnectionMigration, (), (override));
1222 MOCK_METHOD(bool, CanSend, (QuicByteCount), (override));
1223 MOCK_METHOD(QuicBandwidth, PacingRate, (QuicByteCount), (const, override));
1224 MOCK_METHOD(QuicBandwidth, BandwidthEstimate, (), (const, override));
1225 MOCK_METHOD(bool, HasGoodBandwidthEstimateForResumption, (),
1226 (const, override));
1227 MOCK_METHOD(QuicByteCount, GetCongestionWindow, (), (const, override));
1228 MOCK_METHOD(std::string, GetDebugState, (), (const, override));
1229 MOCK_METHOD(bool, InSlowStart, (), (const, override));
1230 MOCK_METHOD(bool, InRecovery, (), (const, override));
1231 MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
1232 MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
1233 (const, override));
1234 MOCK_METHOD(void, AdjustNetworkParameters, (const NetworkParams&),
1235 (override));
1236 MOCK_METHOD(void, OnApplicationLimited, (QuicByteCount), (override));
1237 MOCK_METHOD(void, PopulateConnectionStats, (QuicConnectionStats*),
1238 (const, override));
1239 MOCK_METHOD(bool, SupportsECT0, (), (const, override));
1240 MOCK_METHOD(bool, SupportsECT1, (), (const, override));
1241 };
1242
1243 class MockLossAlgorithm : public LossDetectionInterface {
1244 public:
1245 MockLossAlgorithm();
1246 MockLossAlgorithm(const MockLossAlgorithm&) = delete;
1247 MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete;
1248 ~MockLossAlgorithm() override;
1249
1250 MOCK_METHOD(void, SetFromConfig,
1251 (const QuicConfig& config, Perspective perspective), (override));
1252
1253 MOCK_METHOD(DetectionStats, DetectLosses,
1254 (const QuicUnackedPacketMap& unacked_packets, QuicTime time,
1255 const RttStats& rtt_stats,
1256 QuicPacketNumber largest_recently_acked,
1257 const AckedPacketVector& packets_acked, LostPacketVector*),
1258 (override));
1259 MOCK_METHOD(QuicTime, GetLossTimeout, (), (const, override));
1260 MOCK_METHOD(void, SpuriousLossDetected,
1261 (const QuicUnackedPacketMap&, const RttStats&, QuicTime,
1262 QuicPacketNumber, QuicPacketNumber),
1263 (override));
1264
1265 MOCK_METHOD(void, OnConfigNegotiated, (), (override));
1266 MOCK_METHOD(void, OnMinRttAvailable, (), (override));
1267 MOCK_METHOD(void, OnUserAgentIdKnown, (), (override));
1268 MOCK_METHOD(void, OnConnectionClosed, (), (override));
1269 MOCK_METHOD(void, OnReorderingDetected, (), (override));
1270 };
1271
1272 class MockAckListener : public QuicAckListenerInterface {
1273 public:
1274 MockAckListener();
1275 MockAckListener(const MockAckListener&) = delete;
1276 MockAckListener& operator=(const MockAckListener&) = delete;
1277
1278 MOCK_METHOD(void, OnPacketAcked,
1279 (int acked_bytes, QuicTime::Delta ack_delay_time), (override));
1280
1281 MOCK_METHOD(void, OnPacketRetransmitted, (int retransmitted_bytes),
1282 (override));
1283
1284 protected:
1285 // Object is ref counted.
1286 ~MockAckListener() override;
1287 };
1288
1289 class MockNetworkChangeVisitor
1290 : public QuicSentPacketManager::NetworkChangeVisitor {
1291 public:
1292 MockNetworkChangeVisitor();
1293 MockNetworkChangeVisitor(const MockNetworkChangeVisitor&) = delete;
1294 MockNetworkChangeVisitor& operator=(const MockNetworkChangeVisitor&) = delete;
1295 ~MockNetworkChangeVisitor() override;
1296
1297 MOCK_METHOD(void, OnCongestionChange, (), (override));
1298 MOCK_METHOD(void, OnPathMtuIncreased, (QuicPacketLength), (override));
1299 MOCK_METHOD(void, OnInFlightEcnPacketAcked, (), (override));
1300 MOCK_METHOD(void, OnInvalidEcnFeedback, (), (override));
1301 };
1302
1303 class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
1304 public:
1305 MockQuicConnectionDebugVisitor();
1306 ~MockQuicConnectionDebugVisitor() override;
1307
1308 MOCK_METHOD(void, OnPacketSent,
1309 (QuicPacketNumber, QuicPacketLength, bool, TransmissionType,
1310 EncryptionLevel, const QuicFrames&, const QuicFrames&, QuicTime,
1311 uint32_t),
1312 (override));
1313
1314 MOCK_METHOD(void, OnCoalescedPacketSent, (const QuicCoalescedPacket&, size_t),
1315 (override));
1316
1317 MOCK_METHOD(void, OnPingSent, (), (override));
1318
1319 MOCK_METHOD(void, OnPacketReceived,
1320 (const QuicSocketAddress&, const QuicSocketAddress&,
1321 const QuicEncryptedPacket&),
1322 (override));
1323
1324 MOCK_METHOD(void, OnIncorrectConnectionId, (QuicConnectionId), (override));
1325
1326 MOCK_METHOD(void, OnProtocolVersionMismatch, (ParsedQuicVersion), (override));
1327
1328 MOCK_METHOD(void, OnPacketHeader,
1329 (const QuicPacketHeader& header, QuicTime receive_time,
1330 EncryptionLevel level),
1331 (override));
1332
1333 MOCK_METHOD(void, OnSuccessfulVersionNegotiation, (const ParsedQuicVersion&),
1334 (override));
1335
1336 MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame&), (override));
1337
1338 MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
1339
1340 MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
1341
1342 MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
1343 (override));
1344
1345 MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame&), (override));
1346
1347 MOCK_METHOD(void, OnNewConnectionIdFrame, (const QuicNewConnectionIdFrame&),
1348 (override));
1349
1350 MOCK_METHOD(void, OnRetireConnectionIdFrame,
1351 (const QuicRetireConnectionIdFrame&), (override));
1352
1353 MOCK_METHOD(void, OnNewTokenFrame, (const QuicNewTokenFrame&), (override));
1354
1355 MOCK_METHOD(void, OnMessageFrame, (const QuicMessageFrame&), (override));
1356
1357 MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame&),
1358 (override));
1359
1360 MOCK_METHOD(void, OnPathChallengeFrame, (const QuicPathChallengeFrame&),
1361 (override));
1362
1363 MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
1364 (override));
1365
1366 MOCK_METHOD(void, OnVersionNegotiationPacket,
1367 (const QuicVersionNegotiationPacket&), (override));
1368
1369 MOCK_METHOD(void, OnTransportParametersSent, (const TransportParameters&),
1370 (override));
1371
1372 MOCK_METHOD(void, OnTransportParametersReceived, (const TransportParameters&),
1373 (override));
1374
1375 MOCK_METHOD(void, OnZeroRttRejected, (int), (override));
1376 MOCK_METHOD(void, OnZeroRttPacketAcked, (), (override));
1377 };
1378
1379 class MockReceivedPacketManager : public QuicReceivedPacketManager {
1380 public:
1381 explicit MockReceivedPacketManager(QuicConnectionStats* stats);
1382 ~MockReceivedPacketManager() override;
1383
1384 MOCK_METHOD(void, RecordPacketReceived,
1385 (const QuicPacketHeader& header, QuicTime receipt_time,
1386 const QuicEcnCodepoint ecn),
1387 (override));
1388 MOCK_METHOD(bool, IsMissing, (QuicPacketNumber packet_number), (override));
1389 MOCK_METHOD(bool, IsAwaitingPacket, (QuicPacketNumber packet_number),
1390 (const, override));
1391 MOCK_METHOD(bool, HasNewMissingPackets, (), (const, override));
1392 MOCK_METHOD(bool, ack_frame_updated, (), (const, override));
1393 };
1394
1395 class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface {
1396 public:
1397 MockPacketCreatorDelegate();
1398 MockPacketCreatorDelegate(const MockPacketCreatorDelegate&) = delete;
1399 MockPacketCreatorDelegate& operator=(const MockPacketCreatorDelegate&) =
1400 delete;
1401 ~MockPacketCreatorDelegate() override;
1402
1403 MOCK_METHOD(QuicPacketBuffer, GetPacketBuffer, (), (override));
1404 MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket), (override));
1405 MOCK_METHOD(void, OnUnrecoverableError, (QuicErrorCode, const std::string&),
1406 (override));
1407 MOCK_METHOD(bool, ShouldGeneratePacket,
1408 (HasRetransmittableData retransmittable, IsHandshake handshake),
1409 (override));
1410 MOCK_METHOD(void, MaybeBundleOpportunistically, (), (override));
1411 MOCK_METHOD(QuicByteCount, GetFlowControlSendWindowSize, (QuicStreamId),
1412 (override));
1413 MOCK_METHOD(SerializedPacketFate, GetSerializedPacketFate,
1414 (bool, EncryptionLevel), (override));
1415 };
1416
1417 class MockSessionNotifier : public SessionNotifierInterface {
1418 public:
1419 MockSessionNotifier();
1420 ~MockSessionNotifier() override;
1421
1422 MOCK_METHOD(bool, OnFrameAcked, (const QuicFrame&, QuicTime::Delta, QuicTime),
1423 (override));
1424 MOCK_METHOD(void, OnStreamFrameRetransmitted, (const QuicStreamFrame&),
1425 (override));
1426 MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
1427 MOCK_METHOD(bool, RetransmitFrames,
1428 (const QuicFrames&, TransmissionType type), (override));
1429 MOCK_METHOD(bool, IsFrameOutstanding, (const QuicFrame&), (const, override));
1430 MOCK_METHOD(bool, HasUnackedCryptoData, (), (const, override));
1431 MOCK_METHOD(bool, HasUnackedStreamData, (), (const, override));
1432 };
1433
1434 class MockQuicPathValidationContext : public QuicPathValidationContext {
1435 public:
MockQuicPathValidationContext(const QuicSocketAddress & self_address,const QuicSocketAddress & peer_address,const QuicSocketAddress & effective_peer_address,QuicPacketWriter * writer)1436 MockQuicPathValidationContext(const QuicSocketAddress& self_address,
1437 const QuicSocketAddress& peer_address,
1438 const QuicSocketAddress& effective_peer_address,
1439 QuicPacketWriter* writer)
1440 : QuicPathValidationContext(self_address, peer_address,
1441 effective_peer_address),
1442 writer_(writer) {}
WriterToUse()1443 QuicPacketWriter* WriterToUse() override { return writer_; }
1444
1445 private:
1446 QuicPacketWriter* writer_;
1447 };
1448
1449 class MockQuicPathValidationResultDelegate
1450 : public QuicPathValidator::ResultDelegate {
1451 public:
1452 MOCK_METHOD(void, OnPathValidationSuccess,
1453 (std::unique_ptr<QuicPathValidationContext>, QuicTime),
1454 (override));
1455
1456 MOCK_METHOD(void, OnPathValidationFailure,
1457 (std::unique_ptr<QuicPathValidationContext>), (override));
1458 };
1459
1460 class MockHttpDecoderVisitor : public HttpDecoder::Visitor {
1461 public:
1462 ~MockHttpDecoderVisitor() override = default;
1463
1464 // Called if an error is detected.
1465 MOCK_METHOD(void, OnError, (HttpDecoder*), (override));
1466
1467 MOCK_METHOD(bool, OnMaxPushIdFrame, (), (override));
1468 MOCK_METHOD(bool, OnGoAwayFrame, (const GoAwayFrame& frame), (override));
1469 MOCK_METHOD(bool, OnSettingsFrameStart, (QuicByteCount header_length),
1470 (override));
1471 MOCK_METHOD(bool, OnSettingsFrame, (const SettingsFrame& frame), (override));
1472
1473 MOCK_METHOD(bool, OnDataFrameStart,
1474 (QuicByteCount header_length, QuicByteCount payload_length),
1475 (override));
1476 MOCK_METHOD(bool, OnDataFramePayload, (absl::string_view payload),
1477 (override));
1478 MOCK_METHOD(bool, OnDataFrameEnd, (), (override));
1479
1480 MOCK_METHOD(bool, OnHeadersFrameStart,
1481 (QuicByteCount header_length, QuicByteCount payload_length),
1482 (override));
1483 MOCK_METHOD(bool, OnHeadersFramePayload, (absl::string_view payload),
1484 (override));
1485 MOCK_METHOD(bool, OnHeadersFrameEnd, (), (override));
1486
1487 MOCK_METHOD(bool, OnPriorityUpdateFrameStart, (QuicByteCount header_length),
1488 (override));
1489 MOCK_METHOD(bool, OnPriorityUpdateFrame, (const PriorityUpdateFrame& frame),
1490 (override));
1491
1492 MOCK_METHOD(bool, OnAcceptChFrameStart, (QuicByteCount header_length),
1493 (override));
1494 MOCK_METHOD(bool, OnAcceptChFrame, (const AcceptChFrame& frame), (override));
1495 MOCK_METHOD(void, OnWebTransportStreamFrameType,
1496 (QuicByteCount header_length, WebTransportSessionId session_id),
1497 (override));
1498
1499 MOCK_METHOD(bool, OnUnknownFrameStart,
1500 (uint64_t frame_type, QuicByteCount header_length,
1501 QuicByteCount payload_length),
1502 (override));
1503 MOCK_METHOD(bool, OnUnknownFramePayload, (absl::string_view payload),
1504 (override));
1505 MOCK_METHOD(bool, OnUnknownFrameEnd, (), (override));
1506 };
1507
1508 class QuicCryptoClientStreamPeer {
1509 public:
1510 QuicCryptoClientStreamPeer() = delete;
1511
1512 static QuicCryptoClientStream::HandshakerInterface* GetHandshaker(
1513 QuicCryptoClientStream* stream);
1514 };
1515
1516 // Creates a client session for testing.
1517 //
1518 // server_id: The server id associated with this stream.
1519 // connection_start_time: The time to set for the connection clock.
1520 // Needed for strike-register nonce verification. The client
1521 // connection_start_time should be synchronized witht the server
1522 // start time, otherwise nonce verification will fail.
1523 // supported_versions: Set of QUIC versions this client supports.
1524 // helper: Pointer to the MockQuicConnectionHelper to use for the session.
1525 // crypto_client_config: Pointer to the crypto client config.
1526 // client_connection: Pointer reference for newly created
1527 // connection. This object will be owned by the
1528 // client_session.
1529 // client_session: Pointer reference for the newly created client
1530 // session. The new object will be owned by the caller.
1531 void CreateClientSessionForTest(
1532 QuicServerId server_id, QuicTime::Delta connection_start_time,
1533 const ParsedQuicVersionVector& supported_versions,
1534 MockQuicConnectionHelper* helper, QuicAlarmFactory* alarm_factory,
1535 QuicCryptoClientConfig* crypto_client_config,
1536 PacketSavingConnection** client_connection,
1537 TestQuicSpdyClientSession** client_session);
1538
1539 // Creates a server session for testing.
1540 //
1541 // server_id: The server id associated with this stream.
1542 // connection_start_time: The time to set for the connection clock.
1543 // Needed for strike-register nonce verification. The server
1544 // connection_start_time should be synchronized witht the client
1545 // start time, otherwise nonce verification will fail.
1546 // supported_versions: Set of QUIC versions this server supports.
1547 // helper: Pointer to the MockQuicConnectionHelper to use for the session.
1548 // server_crypto_config: Pointer to the crypto server config.
1549 // server_connection: Pointer reference for newly created
1550 // connection. This object will be owned by the
1551 // server_session.
1552 // server_session: Pointer reference for the newly created server
1553 // session. The new object will be owned by the caller.
1554 void CreateServerSessionForTest(
1555 QuicServerId server_id, QuicTime::Delta connection_start_time,
1556 ParsedQuicVersionVector supported_versions,
1557 MockQuicConnectionHelper* helper, QuicAlarmFactory* alarm_factory,
1558 QuicCryptoServerConfig* server_crypto_config,
1559 QuicCompressedCertsCache* compressed_certs_cache,
1560 PacketSavingConnection** server_connection,
1561 TestQuicSpdyServerSession** server_session);
1562
1563 // Verifies that the relative error of |actual| with respect to |expected| is
1564 // no more than |margin|.
1565 // Please use EXPECT_APPROX_EQ, a wrapper around this function, for better error
1566 // report.
1567 template <typename T>
ExpectApproxEq(T expected,T actual,float relative_margin)1568 void ExpectApproxEq(T expected, T actual, float relative_margin) {
1569 // If |relative_margin| > 1 and T is an unsigned type, the comparison will
1570 // underflow.
1571 ASSERT_LE(relative_margin, 1);
1572 ASSERT_GE(relative_margin, 0);
1573
1574 T absolute_margin = expected * relative_margin;
1575
1576 EXPECT_GE(expected + absolute_margin, actual) << "actual value too big";
1577 EXPECT_LE(expected - absolute_margin, actual) << "actual value too small";
1578 }
1579
1580 #define EXPECT_APPROX_EQ(expected, actual, relative_margin) \
1581 do { \
1582 SCOPED_TRACE(testing::Message() << "relative_margin:" << relative_margin); \
1583 quic::test::ExpectApproxEq(expected, actual, relative_margin); \
1584 } while (0)
1585
1586 template <typename T>
AsHeaderList(const T & container)1587 QuicHeaderList AsHeaderList(const T& container) {
1588 QuicHeaderList l;
1589 l.OnHeaderBlockStart();
1590 size_t total_size = 0;
1591 for (auto p : container) {
1592 total_size += p.first.size() + p.second.size();
1593 l.OnHeader(p.first, p.second);
1594 }
1595 l.OnHeaderBlockEnd(total_size, total_size);
1596 return l;
1597 }
1598
1599 // Helper functions for stream ids, to allow test logic to abstract over the
1600 // HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used
1601 // per HTTP transaction).
1602 QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
1603 QuicTransportVersion version, int n);
1604 QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
1605 QuicTransportVersion version, int n);
1606 QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
1607 QuicTransportVersion version, int n);
1608 QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
1609 QuicTransportVersion version, int n);
1610
1611 StreamType DetermineStreamType(QuicStreamId id, ParsedQuicVersion version,
1612 Perspective perspective, bool is_incoming,
1613 StreamType default_type);
1614
1615 // Creates a MemSlice using a singleton trivial buffer allocator. Performs a
1616 // copy.
1617 quiche::QuicheMemSlice MemSliceFromString(absl::string_view data);
1618
1619 // Used to compare ReceivedPacketInfo.
1620 MATCHER_P(ReceivedPacketInfoEquals, info, "") {
1621 return info.ToString() == arg.ToString();
1622 }
1623
1624 MATCHER_P(ReceivedPacketInfoConnectionIdEquals, destination_connection_id, "") {
1625 return arg.destination_connection_id == destination_connection_id;
1626 }
1627
1628 MATCHER_P2(InRange, min, max, "") { return arg >= min && arg <= max; }
1629
1630 // A GMock matcher that prints expected and actual QuicErrorCode strings
1631 // upon failure. Example usage:
1632 // EXPECT_THAT(stream_->connection_error(), IsError(QUIC_INTERNAL_ERROR));
1633 MATCHER_P(IsError, expected,
1634 absl::StrCat(negation ? "isn't equal to " : "is equal to ",
1635 QuicErrorCodeToString(expected))) {
1636 *result_listener << QuicErrorCodeToString(static_cast<QuicErrorCode>(arg));
1637 return arg == expected;
1638 }
1639
1640 // Shorthand for IsError(QUIC_NO_ERROR).
1641 // Example usage: EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
1642 MATCHER(IsQuicNoError,
1643 absl::StrCat(negation ? "isn't equal to " : "is equal to ",
1644 QuicErrorCodeToString(QUIC_NO_ERROR))) {
1645 *result_listener << QuicErrorCodeToString(arg);
1646 return arg == QUIC_NO_ERROR;
1647 }
1648
1649 // A GMock matcher that prints expected and actual QuicRstStreamErrorCode
1650 // strings upon failure. Example usage:
1651 // EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
1652 MATCHER_P(IsStreamError, expected,
1653 absl::StrCat(negation ? "isn't equal to " : "is equal to ",
1654 QuicRstStreamErrorCodeToString(expected))) {
1655 *result_listener << QuicRstStreamErrorCodeToString(arg);
1656 return arg == expected;
1657 }
1658
1659 // Shorthand for IsStreamError(QUIC_STREAM_NO_ERROR). Example usage:
1660 // EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
1661 MATCHER(IsQuicStreamNoError,
1662 absl::StrCat(negation ? "isn't equal to " : "is equal to ",
1663 QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) {
1664 *result_listener << QuicRstStreamErrorCodeToString(arg);
1665 return arg == QUIC_STREAM_NO_ERROR;
1666 }
1667
1668 // TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
1669 class TaggingEncrypter : public QuicEncrypter {
1670 public:
TaggingEncrypter(uint8_t tag)1671 explicit TaggingEncrypter(uint8_t tag) : tag_(tag) {}
1672 TaggingEncrypter(const TaggingEncrypter&) = delete;
1673 TaggingEncrypter& operator=(const TaggingEncrypter&) = delete;
1674
~TaggingEncrypter()1675 ~TaggingEncrypter() override {}
1676
1677 // QuicEncrypter interface.
SetKey(absl::string_view)1678 bool SetKey(absl::string_view /*key*/) override { return true; }
1679
SetNoncePrefix(absl::string_view)1680 bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
1681 return true;
1682 }
1683
SetIV(absl::string_view)1684 bool SetIV(absl::string_view /*iv*/) override { return true; }
1685
SetHeaderProtectionKey(absl::string_view)1686 bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
1687 return true;
1688 }
1689
1690 bool EncryptPacket(uint64_t packet_number, absl::string_view associated_data,
1691 absl::string_view plaintext, char* output,
1692 size_t* output_length, size_t max_output_length) override;
1693
GenerateHeaderProtectionMask(absl::string_view)1694 std::string GenerateHeaderProtectionMask(
1695 absl::string_view /*sample*/) override {
1696 return std::string(5, 0);
1697 }
1698
GetKeySize()1699 size_t GetKeySize() const override { return 0; }
GetNoncePrefixSize()1700 size_t GetNoncePrefixSize() const override { return 0; }
GetIVSize()1701 size_t GetIVSize() const override { return 0; }
1702
GetMaxPlaintextSize(size_t ciphertext_size)1703 size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
1704 return ciphertext_size - kTagSize;
1705 }
1706
GetCiphertextSize(size_t plaintext_size)1707 size_t GetCiphertextSize(size_t plaintext_size) const override {
1708 return plaintext_size + kTagSize;
1709 }
1710
GetConfidentialityLimit()1711 QuicPacketCount GetConfidentialityLimit() const override {
1712 return std::numeric_limits<QuicPacketCount>::max();
1713 }
1714
GetKey()1715 absl::string_view GetKey() const override { return absl::string_view(); }
1716
GetNoncePrefix()1717 absl::string_view GetNoncePrefix() const override {
1718 return absl::string_view();
1719 }
1720
1721 private:
1722 enum {
1723 kTagSize = 16,
1724 };
1725
1726 const uint8_t tag_;
1727 };
1728
1729 // TaggingDecrypter ensures that the final kTagSize bytes of the message all
1730 // have the same value and then removes them.
1731 class TaggingDecrypter : public QuicDecrypter {
1732 public:
~TaggingDecrypter()1733 ~TaggingDecrypter() override {}
1734
1735 // QuicDecrypter interface
SetKey(absl::string_view)1736 bool SetKey(absl::string_view /*key*/) override { return true; }
1737
SetNoncePrefix(absl::string_view)1738 bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
1739 return true;
1740 }
1741
SetIV(absl::string_view)1742 bool SetIV(absl::string_view /*iv*/) override { return true; }
1743
SetHeaderProtectionKey(absl::string_view)1744 bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
1745 return true;
1746 }
1747
SetPreliminaryKey(absl::string_view)1748 bool SetPreliminaryKey(absl::string_view /*key*/) override {
1749 QUIC_BUG(quic_bug_10230_1) << "should not be called";
1750 return false;
1751 }
1752
SetDiversificationNonce(const DiversificationNonce &)1753 bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
1754 return true;
1755 }
1756
1757 bool DecryptPacket(uint64_t packet_number, absl::string_view associated_data,
1758 absl::string_view ciphertext, char* output,
1759 size_t* output_length, size_t max_output_length) override;
1760
GenerateHeaderProtectionMask(QuicDataReader *)1761 std::string GenerateHeaderProtectionMask(
1762 QuicDataReader* /*sample_reader*/) override {
1763 return std::string(5, 0);
1764 }
1765
GetKeySize()1766 size_t GetKeySize() const override { return 0; }
GetNoncePrefixSize()1767 size_t GetNoncePrefixSize() const override { return 0; }
GetIVSize()1768 size_t GetIVSize() const override { return 0; }
GetKey()1769 absl::string_view GetKey() const override { return absl::string_view(); }
GetNoncePrefix()1770 absl::string_view GetNoncePrefix() const override {
1771 return absl::string_view();
1772 }
1773 // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
cipher_id()1774 uint32_t cipher_id() const override { return 0xFFFFFFF0; }
GetIntegrityLimit()1775 QuicPacketCount GetIntegrityLimit() const override {
1776 return std::numeric_limits<QuicPacketCount>::max();
1777 }
1778
1779 protected:
GetTag(absl::string_view ciphertext)1780 virtual uint8_t GetTag(absl::string_view ciphertext) {
1781 return ciphertext.data()[ciphertext.size() - 1];
1782 }
1783
1784 private:
1785 enum {
1786 kTagSize = 16,
1787 };
1788
1789 bool CheckTag(absl::string_view ciphertext, uint8_t tag);
1790 };
1791
1792 // StringTaggingDecrypter ensures that the final kTagSize bytes of the message
1793 // match the expected value.
1794 class StrictTaggingDecrypter : public TaggingDecrypter {
1795 public:
StrictTaggingDecrypter(uint8_t tag)1796 explicit StrictTaggingDecrypter(uint8_t tag) : tag_(tag) {}
~StrictTaggingDecrypter()1797 ~StrictTaggingDecrypter() override {}
1798
1799 // TaggingQuicDecrypter
GetTag(absl::string_view)1800 uint8_t GetTag(absl::string_view /*ciphertext*/) override { return tag_; }
1801
1802 // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
cipher_id()1803 uint32_t cipher_id() const override { return 0xFFFFFFF1; }
1804
1805 private:
1806 const uint8_t tag_;
1807 };
1808
1809 class TestPacketWriter : public QuicPacketWriter {
1810 struct PacketBuffer {
1811 ABSL_CACHELINE_ALIGNED char buffer[1500];
1812 bool in_use = false;
1813 };
1814
1815 public:
1816 TestPacketWriter(ParsedQuicVersion version, MockClock* clock,
1817 Perspective perspective);
1818
1819 TestPacketWriter(const TestPacketWriter&) = delete;
1820 TestPacketWriter& operator=(const TestPacketWriter&) = delete;
1821
1822 ~TestPacketWriter() override;
1823
1824 // QuicPacketWriter interface
1825 WriteResult WritePacket(const char* buffer, size_t buf_len,
1826 const QuicIpAddress& self_address,
1827 const QuicSocketAddress& peer_address,
1828 PerPacketOptions* options,
1829 const QuicPacketWriterParams& params) override;
1830
ShouldWriteFail()1831 bool ShouldWriteFail() { return write_should_fail_; }
1832
IsWriteBlocked()1833 bool IsWriteBlocked() const override { return write_blocked_; }
1834
MessageTooBigErrorCode()1835 std::optional<int> MessageTooBigErrorCode() const override { return 0x1234; }
1836
SetWriteBlocked()1837 void SetWriteBlocked() { write_blocked_ = true; }
1838
SetWritable()1839 void SetWritable() override { write_blocked_ = false; }
1840
SetShouldWriteFail()1841 void SetShouldWriteFail() { write_should_fail_ = true; }
1842
SetWriteError(int error_code)1843 void SetWriteError(int error_code) { write_error_code_ = error_code; }
1844
GetMaxPacketSize(const QuicSocketAddress &)1845 QuicByteCount GetMaxPacketSize(
1846 const QuicSocketAddress& /*peer_address*/) const override {
1847 return max_packet_size_;
1848 }
1849
SupportsReleaseTime()1850 bool SupportsReleaseTime() const override { return supports_release_time_; }
1851
IsBatchMode()1852 bool IsBatchMode() const override { return is_batch_mode_; }
1853
SupportsEcn()1854 bool SupportsEcn() const override { return true; }
1855
1856 QuicPacketBuffer GetNextWriteLocation(
1857 const QuicIpAddress& /*self_address*/,
1858 const QuicSocketAddress& /*peer_address*/) override;
1859
1860 WriteResult Flush() override;
1861
BlockOnNextFlush()1862 void BlockOnNextFlush() { block_on_next_flush_ = true; }
1863
BlockOnNextWrite()1864 void BlockOnNextWrite() { block_on_next_write_ = true; }
1865
SimulateNextPacketTooLarge()1866 void SimulateNextPacketTooLarge() { next_packet_too_large_ = true; }
1867
ExpectNextPacketUnprocessable()1868 void ExpectNextPacketUnprocessable() { next_packet_processable_ = false; }
1869
AlwaysGetPacketTooLarge()1870 void AlwaysGetPacketTooLarge() { always_get_packet_too_large_ = true; }
1871
1872 // Sets the amount of time that the writer should before the actual write.
SetWritePauseTimeDelta(QuicTime::Delta delta)1873 void SetWritePauseTimeDelta(QuicTime::Delta delta) {
1874 write_pause_time_delta_ = delta;
1875 }
1876
SetBatchMode(bool new_value)1877 void SetBatchMode(bool new_value) { is_batch_mode_ = new_value; }
1878
header()1879 const QuicPacketHeader& header() { return framer_.header(); }
1880
frame_count()1881 size_t frame_count() const { return framer_.num_frames(); }
1882
ack_frames()1883 const std::vector<QuicAckFrame>& ack_frames() const {
1884 return framer_.ack_frames();
1885 }
1886
stop_waiting_frames()1887 const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
1888 return framer_.stop_waiting_frames();
1889 }
1890
connection_close_frames()1891 const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const {
1892 return framer_.connection_close_frames();
1893 }
1894
rst_stream_frames()1895 const std::vector<QuicRstStreamFrame>& rst_stream_frames() const {
1896 return framer_.rst_stream_frames();
1897 }
1898
stream_frames()1899 const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
1900 return framer_.stream_frames();
1901 }
1902
crypto_frames()1903 const std::vector<std::unique_ptr<QuicCryptoFrame>>& crypto_frames() const {
1904 return framer_.crypto_frames();
1905 }
1906
ping_frames()1907 const std::vector<QuicPingFrame>& ping_frames() const {
1908 return framer_.ping_frames();
1909 }
1910
message_frames()1911 const std::vector<QuicMessageFrame>& message_frames() const {
1912 return framer_.message_frames();
1913 }
1914
window_update_frames()1915 const std::vector<QuicWindowUpdateFrame>& window_update_frames() const {
1916 return framer_.window_update_frames();
1917 }
1918
padding_frames()1919 const std::vector<QuicPaddingFrame>& padding_frames() const {
1920 return framer_.padding_frames();
1921 }
1922
path_challenge_frames()1923 const std::vector<QuicPathChallengeFrame>& path_challenge_frames() const {
1924 return framer_.path_challenge_frames();
1925 }
1926
path_response_frames()1927 const std::vector<QuicPathResponseFrame>& path_response_frames() const {
1928 return framer_.path_response_frames();
1929 }
1930
coalesced_packet()1931 const QuicEncryptedPacket* coalesced_packet() const {
1932 return framer_.coalesced_packet();
1933 }
1934
last_packet_size()1935 size_t last_packet_size() const { return last_packet_size_; }
1936
total_bytes_written()1937 size_t total_bytes_written() const { return total_bytes_written_; }
1938
last_packet_header()1939 const QuicPacketHeader& last_packet_header() const {
1940 return last_packet_header_;
1941 }
1942
version_negotiation_packet()1943 const QuicVersionNegotiationPacket* version_negotiation_packet() {
1944 return framer_.version_negotiation_packet();
1945 }
1946
set_is_write_blocked_data_buffered(bool buffered)1947 void set_is_write_blocked_data_buffered(bool buffered) {
1948 is_write_blocked_data_buffered_ = buffered;
1949 }
1950
set_perspective(Perspective perspective)1951 void set_perspective(Perspective perspective) {
1952 // We invert perspective here, because the framer needs to parse packets
1953 // we send.
1954 QuicFramerPeer::SetPerspective(framer_.framer(),
1955 QuicUtils::InvertPerspective(perspective));
1956 framer_.framer()->SetInitialObfuscators(TestConnectionId());
1957 }
1958
1959 // final_bytes_of_last_packet_ returns the last four bytes of the previous
1960 // packet as a little-endian, uint32_t. This is intended to be used with a
1961 // TaggingEncrypter so that tests can determine which encrypter was used for
1962 // a given packet.
final_bytes_of_last_packet()1963 uint32_t final_bytes_of_last_packet() { return final_bytes_of_last_packet_; }
1964
1965 // Returns the final bytes of the second to last packet.
final_bytes_of_previous_packet()1966 uint32_t final_bytes_of_previous_packet() {
1967 return final_bytes_of_previous_packet_;
1968 }
1969
packets_write_attempts()1970 uint32_t packets_write_attempts() const { return packets_write_attempts_; }
1971
flush_attempts()1972 uint32_t flush_attempts() const { return flush_attempts_; }
1973
connection_close_packets()1974 uint32_t connection_close_packets() const {
1975 return connection_close_packets_;
1976 }
1977
Reset()1978 void Reset() { framer_.Reset(); }
1979
SetSupportedVersions(const ParsedQuicVersionVector & versions)1980 void SetSupportedVersions(const ParsedQuicVersionVector& versions) {
1981 framer_.SetSupportedVersions(versions);
1982 }
1983
set_max_packet_size(QuicByteCount max_packet_size)1984 void set_max_packet_size(QuicByteCount max_packet_size) {
1985 max_packet_size_ = max_packet_size;
1986 }
1987
set_supports_release_time(bool supports_release_time)1988 void set_supports_release_time(bool supports_release_time) {
1989 supports_release_time_ = supports_release_time;
1990 }
1991
framer()1992 SimpleQuicFramer* framer() { return &framer_; }
1993
last_write_source_address()1994 const QuicIpAddress& last_write_source_address() const {
1995 return last_write_source_address_;
1996 }
1997
last_write_peer_address()1998 const QuicSocketAddress& last_write_peer_address() const {
1999 return last_write_peer_address_;
2000 }
2001
last_ecn_sent()2002 QuicEcnCodepoint last_ecn_sent() const { return last_ecn_sent_; }
2003
2004 private:
2005 char* AllocPacketBuffer();
2006
2007 void FreePacketBuffer(const char* buffer);
2008
2009 ParsedQuicVersion version_;
2010 SimpleQuicFramer framer_;
2011 size_t last_packet_size_ = 0;
2012 size_t total_bytes_written_ = 0;
2013 QuicPacketHeader last_packet_header_;
2014 bool write_blocked_ = false;
2015 bool write_should_fail_ = false;
2016 bool block_on_next_flush_ = false;
2017 bool block_on_next_write_ = false;
2018 bool next_packet_too_large_ = false;
2019 bool next_packet_processable_ = true;
2020 bool always_get_packet_too_large_ = false;
2021 bool is_write_blocked_data_buffered_ = false;
2022 bool is_batch_mode_ = false;
2023 // Number of times Flush() was called.
2024 uint32_t flush_attempts_ = 0;
2025 // (Batch mode only) Number of bytes buffered in writer. It is used as the
2026 // return value of a successful Flush().
2027 uint32_t bytes_buffered_ = 0;
2028 uint32_t final_bytes_of_last_packet_ = 0;
2029 uint32_t final_bytes_of_previous_packet_ = 0;
2030 uint32_t packets_write_attempts_ = 0;
2031 uint32_t connection_close_packets_ = 0;
2032 MockClock* clock_ = nullptr;
2033 // If non-zero, the clock will pause during WritePacket for this amount of
2034 // time.
2035 QuicTime::Delta write_pause_time_delta_ = QuicTime::Delta::Zero();
2036 QuicByteCount max_packet_size_ = kMaxOutgoingPacketSize;
2037 bool supports_release_time_ = false;
2038 // Used to verify writer-allocated packet buffers are properly released.
2039 std::vector<PacketBuffer*> packet_buffer_pool_;
2040 // Buffer address => Address of the owning PacketBuffer.
2041 absl::flat_hash_map<char*, PacketBuffer*, absl::Hash<char*>>
2042 packet_buffer_pool_index_;
2043 // Indices in packet_buffer_pool_ that are not allocated.
2044 std::list<PacketBuffer*> packet_buffer_free_list_;
2045 // The soruce/peer address passed into WritePacket().
2046 QuicIpAddress last_write_source_address_;
2047 QuicSocketAddress last_write_peer_address_;
2048 int write_error_code_{0};
2049 QuicEcnCodepoint last_ecn_sent_ = ECN_NOT_ECT;
2050 };
2051
2052 // Parses a packet generated by
2053 // QuicFramer::WriteClientVersionNegotiationProbePacket.
2054 // |packet_bytes| must point to |packet_length| bytes in memory which represent
2055 // the packet. This method will fill in |destination_connection_id_bytes|
2056 // which must point to at least |*destination_connection_id_length_out| bytes in
2057 // memory. |*destination_connection_id_length_out| will contain the length of
2058 // the received destination connection ID, which on success will match the
2059 // contents of the destination connection ID passed in to
2060 // WriteClientVersionNegotiationProbePacket.
2061 bool ParseClientVersionNegotiationProbePacket(
2062 const char* packet_bytes, size_t packet_length,
2063 char* destination_connection_id_bytes,
2064 uint8_t* destination_connection_id_length_out);
2065
2066 // Writes an array of bytes that correspond to a QUIC version negotiation packet
2067 // that a QUIC server would send in response to a probe created by
2068 // QuicFramer::WriteClientVersionNegotiationProbePacket.
2069 // The bytes will be written to |packet_bytes|, which must point to
2070 // |*packet_length_out| bytes of memory. |*packet_length_out| will contain the
2071 // length of the created packet. |source_connection_id_bytes| will be sent as
2072 // the source connection ID, and must point to |source_connection_id_length|
2073 // bytes of memory.
2074 bool WriteServerVersionNegotiationProbeResponse(
2075 char* packet_bytes, size_t* packet_length_out,
2076 const char* source_connection_id_bytes,
2077 uint8_t source_connection_id_length);
2078
2079 // Implementation of Http3DatagramVisitor which saves all received datagrams.
2080 class SavingHttp3DatagramVisitor : public QuicSpdyStream::Http3DatagramVisitor {
2081 public:
2082 struct SavedHttp3Datagram {
2083 QuicStreamId stream_id;
2084 std::string payload;
2085 bool operator==(const SavedHttp3Datagram& o) const {
2086 return stream_id == o.stream_id && payload == o.payload;
2087 }
2088 };
2089 struct SavedUnknownCapsule {
2090 QuicStreamId stream_id;
2091 uint64_t type;
2092 std::string payload;
2093 bool operator==(const SavedUnknownCapsule& o) const {
2094 return stream_id == o.stream_id && type == o.type && payload == o.payload;
2095 }
2096 };
received_h3_datagrams()2097 const std::vector<SavedHttp3Datagram>& received_h3_datagrams() const {
2098 return received_h3_datagrams_;
2099 }
received_unknown_capsules()2100 const std::vector<SavedUnknownCapsule>& received_unknown_capsules() const {
2101 return received_unknown_capsules_;
2102 }
2103
2104 // Override from QuicSpdyStream::Http3DatagramVisitor.
OnHttp3Datagram(QuicStreamId stream_id,absl::string_view payload)2105 void OnHttp3Datagram(QuicStreamId stream_id,
2106 absl::string_view payload) override {
2107 received_h3_datagrams_.push_back(
2108 SavedHttp3Datagram{stream_id, std::string(payload)});
2109 }
OnUnknownCapsule(QuicStreamId stream_id,const quiche::UnknownCapsule & capsule)2110 void OnUnknownCapsule(QuicStreamId stream_id,
2111 const quiche::UnknownCapsule& capsule) override {
2112 received_unknown_capsules_.push_back(SavedUnknownCapsule{
2113 stream_id, capsule.type, std::string(capsule.payload)});
2114 }
2115
2116 private:
2117 std::vector<SavedHttp3Datagram> received_h3_datagrams_;
2118 std::vector<SavedUnknownCapsule> received_unknown_capsules_;
2119 };
2120
2121 // Implementation of ConnectIpVisitor which saves all received capsules.
2122 class SavingConnectIpVisitor : public QuicSpdyStream::ConnectIpVisitor {
2123 public:
2124 const std::vector<quiche::AddressAssignCapsule>&
received_address_assign_capsules()2125 received_address_assign_capsules() const {
2126 return received_address_assign_capsules_;
2127 }
2128 const std::vector<quiche::AddressRequestCapsule>&
received_address_request_capsules()2129 received_address_request_capsules() const {
2130 return received_address_request_capsules_;
2131 }
2132 const std::vector<quiche::RouteAdvertisementCapsule>&
received_route_advertisement_capsules()2133 received_route_advertisement_capsules() const {
2134 return received_route_advertisement_capsules_;
2135 }
headers_written()2136 bool headers_written() const { return headers_written_; }
2137
2138 // From QuicSpdyStream::ConnectIpVisitor.
OnAddressAssignCapsule(const quiche::AddressAssignCapsule & capsule)2139 bool OnAddressAssignCapsule(
2140 const quiche::AddressAssignCapsule& capsule) override {
2141 received_address_assign_capsules_.push_back(capsule);
2142 return true;
2143 }
OnAddressRequestCapsule(const quiche::AddressRequestCapsule & capsule)2144 bool OnAddressRequestCapsule(
2145 const quiche::AddressRequestCapsule& capsule) override {
2146 received_address_request_capsules_.push_back(capsule);
2147 return true;
2148 }
OnRouteAdvertisementCapsule(const quiche::RouteAdvertisementCapsule & capsule)2149 bool OnRouteAdvertisementCapsule(
2150 const quiche::RouteAdvertisementCapsule& capsule) override {
2151 received_route_advertisement_capsules_.push_back(capsule);
2152 return true;
2153 }
OnHeadersWritten()2154 void OnHeadersWritten() override { headers_written_ = true; }
2155
2156 private:
2157 std::vector<quiche::AddressAssignCapsule> received_address_assign_capsules_;
2158 std::vector<quiche::AddressRequestCapsule> received_address_request_capsules_;
2159 std::vector<quiche::RouteAdvertisementCapsule>
2160 received_route_advertisement_capsules_;
2161 bool headers_written_ = false;
2162 };
2163
EscapeTestParamName(absl::string_view name)2164 inline std::string EscapeTestParamName(absl::string_view name) {
2165 std::string result(name);
2166 // Escape all characters that are not allowed by gtest ([a-zA-Z0-9_]).
2167 for (char& c : result) {
2168 bool valid = absl::ascii_isalnum(c) || c == '_';
2169 if (!valid) {
2170 c = '_';
2171 }
2172 }
2173 return result;
2174 }
2175
2176 } // namespace test
2177 } // namespace quic
2178
2179 #endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
2180