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