Relocate QUICHE files into quiche/ directory within the quiche repo, and change the relative include paths accordingly.
PiperOrigin-RevId: 440164720
Change-Id: I64d8a975d08888a3a86f6c51908e63d5cd45fa35
diff --git a/quiche/quic/test_tools/bad_packet_writer.cc b/quiche/quic/test_tools/bad_packet_writer.cc
new file mode 100644
index 0000000..114e136
--- /dev/null
+++ b/quiche/quic/test_tools/bad_packet_writer.cc
@@ -0,0 +1,36 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/bad_packet_writer.h"
+
+namespace quic {
+namespace test {
+
+BadPacketWriter::BadPacketWriter(size_t packet_causing_write_error,
+ int error_code)
+ : packet_causing_write_error_(packet_causing_write_error),
+ error_code_(error_code) {}
+
+BadPacketWriter::~BadPacketWriter() {}
+
+WriteResult BadPacketWriter::WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) {
+ if (error_code_ == 0 || packet_causing_write_error_ > 0) {
+ if (packet_causing_write_error_ > 0) {
+ --packet_causing_write_error_;
+ }
+ return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
+ peer_address, options);
+ }
+ // It's time to cause write error.
+ int error_code = error_code_;
+ error_code_ = 0;
+ return WriteResult(WRITE_STATUS_ERROR, error_code);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/bad_packet_writer.h b/quiche/quic/test_tools/bad_packet_writer.h
new file mode 100644
index 0000000..7ba8383
--- /dev/null
+++ b/quiche/quic/test_tools/bad_packet_writer.h
@@ -0,0 +1,36 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_BAD_PACKET_WRITER_H_
+#define QUICHE_QUIC_TEST_TOOLS_BAD_PACKET_WRITER_H_
+
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+
+namespace quic {
+
+namespace test {
+// This packet writer allows causing packet write error with specified error
+// code when writing a particular packet.
+class BadPacketWriter : public QuicPacketWriterWrapper {
+ public:
+ BadPacketWriter(size_t packet_causing_write_error, int error_code);
+
+ ~BadPacketWriter() override;
+
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ private:
+ size_t packet_causing_write_error_;
+ int error_code_;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_BAD_PACKET_WRITER_H_
diff --git a/quiche/quic/test_tools/crypto_test_utils.cc b/quiche/quic/test_tools/crypto_test_utils.cc
new file mode 100644
index 0000000..9ee83ed
--- /dev/null
+++ b/quiche/quic/test_tools/crypto_test_utils.cc
@@ -0,0 +1,862 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
+#include "third_party/boringssl/src/include/openssl/bn.h"
+#include "third_party/boringssl/src/include/openssl/ec.h"
+#include "third_party/boringssl/src/include/openssl/ecdsa.h"
+#include "third_party/boringssl/src/include/openssl/nid.h"
+#include "third_party/boringssl/src/include/openssl/sha.h"
+#include "quiche/quic/core/crypto/channel_id.h"
+#include "quiche/quic/core/crypto/crypto_handshake.h"
+#include "quiche/quic/core/crypto/quic_crypto_server_config.h"
+#include "quiche/quic/core/crypto/quic_decrypter.h"
+#include "quiche/quic/core/crypto/quic_encrypter.h"
+#include "quiche/quic/core/crypto/quic_random.h"
+#include "quiche/quic/core/proto/crypto_server_config_proto.h"
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_crypto_client_stream.h"
+#include "quiche/quic/core/quic_crypto_server_stream_base.h"
+#include "quiche/quic/core/quic_crypto_stream.h"
+#include "quiche/quic/core/quic_server_id.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/core/quic_versions.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_framer_peer.h"
+#include "quiche/quic/test_tools/quic_stream_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simple_quic_framer.h"
+#include "quiche/common/test_tools/quiche_test_utils.h"
+
+namespace quic {
+namespace test {
+
+namespace crypto_test_utils {
+
+namespace {
+
+using testing::_;
+
+// CryptoFramerVisitor is a framer visitor that records handshake messages.
+class CryptoFramerVisitor : public CryptoFramerVisitorInterface {
+ public:
+ CryptoFramerVisitor() : error_(false) {}
+
+ void OnError(CryptoFramer* /*framer*/) override { error_ = true; }
+
+ void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
+ messages_.push_back(message);
+ }
+
+ bool error() const { return error_; }
+
+ const std::vector<CryptoHandshakeMessage>& messages() const {
+ return messages_;
+ }
+
+ private:
+ bool error_;
+ std::vector<CryptoHandshakeMessage> messages_;
+};
+
+// HexChar parses |c| as a hex character. If valid, it sets |*value| to the
+// value of the hex character and returns true. Otherwise it returns false.
+bool HexChar(char c, uint8_t* value) {
+ if (c >= '0' && c <= '9') {
+ *value = c - '0';
+ return true;
+ }
+ if (c >= 'a' && c <= 'f') {
+ *value = c - 'a' + 10;
+ return true;
+ }
+ if (c >= 'A' && c <= 'F') {
+ *value = c - 'A' + 10;
+ return true;
+ }
+ return false;
+}
+
+} // anonymous namespace
+
+FakeClientOptions::FakeClientOptions() {}
+
+FakeClientOptions::~FakeClientOptions() {}
+
+namespace {
+// This class is used by GenerateFullCHLO() to extract SCID and STK from
+// REJ and to construct a full CHLO with these fields and given inchoate
+// CHLO.
+class FullChloGenerator {
+ public:
+ FullChloGenerator(
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, const QuicClock* clock,
+ ParsedQuicVersion version,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ CryptoHandshakeMessage* out)
+ : crypto_config_(crypto_config),
+ server_addr_(server_addr),
+ client_addr_(client_addr),
+ clock_(clock),
+ version_(version),
+ signed_config_(signed_config),
+ compressed_certs_cache_(compressed_certs_cache),
+ out_(out),
+ params_(new QuicCryptoNegotiatedParameters) {}
+
+ class ValidateClientHelloCallback : public ValidateClientHelloResultCallback {
+ public:
+ explicit ValidateClientHelloCallback(FullChloGenerator* generator)
+ : generator_(generator) {}
+ void Run(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result,
+ std::unique_ptr<ProofSource::Details> /* details */) override {
+ generator_->ValidateClientHelloDone(std::move(result));
+ }
+
+ private:
+ FullChloGenerator* generator_;
+ };
+
+ std::unique_ptr<ValidateClientHelloCallback>
+ GetValidateClientHelloCallback() {
+ return std::make_unique<ValidateClientHelloCallback>(this);
+ }
+
+ private:
+ void ValidateClientHelloDone(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result) {
+ result_ = result;
+ crypto_config_->ProcessClientHello(
+ result_, /*reject_only=*/false, TestConnectionId(1), server_addr_,
+ client_addr_, version_, {version_}, clock_, QuicRandom::GetInstance(),
+ compressed_certs_cache_, params_, signed_config_,
+ /*total_framing_overhead=*/50, kDefaultMaxPacketSize,
+ GetProcessClientHelloCallback());
+ }
+
+ class ProcessClientHelloCallback : public ProcessClientHelloResultCallback {
+ public:
+ explicit ProcessClientHelloCallback(FullChloGenerator* generator)
+ : generator_(generator) {}
+ void Run(QuicErrorCode error,
+ const std::string& error_details,
+ std::unique_ptr<CryptoHandshakeMessage> message,
+ std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
+ std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
+ override {
+ ASSERT_TRUE(message) << QuicErrorCodeToString(error) << " "
+ << error_details;
+ generator_->ProcessClientHelloDone(std::move(message));
+ }
+
+ private:
+ FullChloGenerator* generator_;
+ };
+
+ std::unique_ptr<ProcessClientHelloCallback> GetProcessClientHelloCallback() {
+ return std::make_unique<ProcessClientHelloCallback>(this);
+ }
+
+ void ProcessClientHelloDone(std::unique_ptr<CryptoHandshakeMessage> rej) {
+ // Verify output is a REJ.
+ EXPECT_THAT(rej->tag(), testing::Eq(kREJ));
+
+ QUIC_VLOG(1) << "Extract valid STK and SCID from\n" << rej->DebugString();
+ absl::string_view srct;
+ ASSERT_TRUE(rej->GetStringPiece(kSourceAddressTokenTag, &srct));
+
+ absl::string_view scfg;
+ ASSERT_TRUE(rej->GetStringPiece(kSCFG, &scfg));
+ std::unique_ptr<CryptoHandshakeMessage> server_config(
+ CryptoFramer::ParseMessage(scfg));
+
+ absl::string_view scid;
+ ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
+
+ *out_ = result_->client_hello;
+ out_->SetStringPiece(kSCID, scid);
+ out_->SetStringPiece(kSourceAddressTokenTag, srct);
+ uint64_t xlct = LeafCertHashForTesting();
+ out_->SetValue(kXLCT, xlct);
+ }
+
+ protected:
+ QuicCryptoServerConfig* crypto_config_;
+ QuicSocketAddress server_addr_;
+ QuicSocketAddress client_addr_;
+ const QuicClock* clock_;
+ ParsedQuicVersion version_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ QuicCompressedCertsCache* compressed_certs_cache_;
+ CryptoHandshakeMessage* out_;
+
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result_;
+};
+
+} // namespace
+
+std::unique_ptr<QuicCryptoServerConfig> CryptoServerConfigForTesting() {
+ return std::make_unique<QuicCryptoServerConfig>(
+ QuicCryptoServerConfig::TESTING, QuicRandom::GetInstance(),
+ ProofSourceForTesting(), KeyExchangeSource::Default());
+}
+
+int HandshakeWithFakeServer(QuicConfig* server_quic_config,
+ QuicCryptoServerConfig* crypto_config,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ PacketSavingConnection* client_conn,
+ QuicCryptoClientStreamBase* client,
+ std::string alpn) {
+ auto* server_conn = new testing::NiceMock<PacketSavingConnection>(
+ helper, alarm_factory, Perspective::IS_SERVER,
+ ParsedVersionOfIndex(client_conn->supported_versions(), 0));
+
+ QuicCompressedCertsCache compressed_certs_cache(
+ QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
+ SetupCryptoServerConfigForTest(
+ server_conn->clock(), server_conn->random_generator(), crypto_config);
+
+ TestQuicSpdyServerSession server_session(
+ server_conn, *server_quic_config, client_conn->supported_versions(),
+ crypto_config, &compressed_certs_cache);
+ // Call SetServerApplicationStateForResumption so that the fake server
+ // supports 0-RTT in TLS.
+ server_session.Initialize();
+ server_session.GetMutableCryptoStream()
+ ->SetServerApplicationStateForResumption(
+ std::make_unique<ApplicationState>());
+ EXPECT_CALL(*server_session.helper(),
+ CanAcceptClientHello(testing::_, testing::_, testing::_,
+ testing::_, testing::_))
+ .Times(testing::AnyNumber());
+ EXPECT_CALL(*server_conn, OnCanWrite()).Times(testing::AnyNumber());
+ EXPECT_CALL(*client_conn, OnCanWrite()).Times(testing::AnyNumber());
+ EXPECT_CALL(*server_conn, SendCryptoData(_, _, _))
+ .Times(testing::AnyNumber());
+ EXPECT_CALL(server_session, SelectAlpn(_))
+ .WillRepeatedly([alpn](const std::vector<absl::string_view>& alpns) {
+ return std::find(alpns.cbegin(), alpns.cend(), alpn);
+ });
+
+ // The client's handshake must have been started already.
+ QUICHE_CHECK_NE(0u, client_conn->encrypted_packets_.size());
+
+ CommunicateHandshakeMessages(client_conn, client, server_conn,
+ server_session.GetMutableCryptoStream());
+ if (client_conn->connected() && server_conn->connected()) {
+ CompareClientAndServerKeys(client, server_session.GetMutableCryptoStream());
+ }
+
+ return client->num_sent_client_hellos();
+}
+
+int HandshakeWithFakeClient(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ PacketSavingConnection* server_conn,
+ QuicCryptoServerStreamBase* server,
+ const QuicServerId& server_id,
+ const FakeClientOptions& options,
+ std::string alpn) {
+ // This function does not do version negotiation; read the supported versions
+ // directly from the server connection instead.
+ ParsedQuicVersionVector supported_versions =
+ server_conn->supported_versions();
+ if (options.only_tls_versions) {
+ supported_versions.erase(
+ std::remove_if(supported_versions.begin(), supported_versions.end(),
+ [](const ParsedQuicVersion& version) {
+ return version.handshake_protocol != PROTOCOL_TLS1_3;
+ }),
+ supported_versions.end());
+ QUICHE_CHECK(!options.only_quic_crypto_versions);
+ } else if (options.only_quic_crypto_versions) {
+ supported_versions.erase(
+ std::remove_if(supported_versions.begin(), supported_versions.end(),
+ [](const ParsedQuicVersion& version) {
+ return version.handshake_protocol !=
+ PROTOCOL_QUIC_CRYPTO;
+ }),
+ supported_versions.end());
+ }
+ PacketSavingConnection* client_conn = new PacketSavingConnection(
+ helper, alarm_factory, Perspective::IS_CLIENT, supported_versions);
+ // Advance the time, because timers do not like uninitialized times.
+ client_conn->AdvanceTime(QuicTime::Delta::FromSeconds(1));
+
+ QuicCryptoClientConfig crypto_config(ProofVerifierForTesting());
+ TestQuicSpdyClientSession client_session(client_conn, DefaultQuicConfig(),
+ supported_versions, server_id,
+ &crypto_config);
+
+ EXPECT_CALL(client_session, OnProofValid(testing::_))
+ .Times(testing::AnyNumber());
+ EXPECT_CALL(client_session, OnProofVerifyDetailsAvailable(testing::_))
+ .Times(testing::AnyNumber());
+ EXPECT_CALL(*client_conn, OnCanWrite()).Times(testing::AnyNumber());
+ if (!alpn.empty()) {
+ EXPECT_CALL(client_session, GetAlpnsToOffer())
+ .WillRepeatedly(testing::Return(std::vector<std::string>({alpn})));
+ } else {
+ EXPECT_CALL(client_session, GetAlpnsToOffer())
+ .WillRepeatedly(testing::Return(std::vector<std::string>(
+ {AlpnForVersion(client_conn->version())})));
+ }
+ client_session.GetMutableCryptoStream()->CryptoConnect();
+ QUICHE_CHECK_EQ(1u, client_conn->encrypted_packets_.size());
+
+ CommunicateHandshakeMessages(client_conn,
+ client_session.GetMutableCryptoStream(),
+ server_conn, server);
+
+ if (server->one_rtt_keys_available() && server->encryption_established()) {
+ CompareClientAndServerKeys(client_session.GetMutableCryptoStream(), server);
+ }
+
+ return client_session.GetCryptoStream()->num_sent_client_hellos();
+}
+
+void SetupCryptoServerConfigForTest(const QuicClock* clock,
+ QuicRandom* rand,
+ QuicCryptoServerConfig* crypto_config) {
+ QuicCryptoServerConfig::ConfigOptions options;
+ options.channel_id_enabled = true;
+ std::unique_ptr<CryptoHandshakeMessage> scfg =
+ crypto_config->AddDefaultConfig(rand, clock, options);
+}
+
+void SendHandshakeMessageToStream(QuicCryptoStream* stream,
+ const CryptoHandshakeMessage& message,
+ Perspective /*perspective*/) {
+ const QuicData& data = message.GetSerialized();
+ QuicSession* session = QuicStreamPeer::session(stream);
+ if (!QuicVersionUsesCryptoFrames(session->transport_version())) {
+ QuicStreamFrame frame(
+ QuicUtils::GetCryptoStreamId(session->transport_version()), false,
+ stream->crypto_bytes_read(), data.AsStringPiece());
+ stream->OnStreamFrame(frame);
+ } else {
+ EncryptionLevel level = session->connection()->last_decrypted_level();
+ QuicCryptoFrame frame(level, stream->BytesReadOnLevel(level),
+ data.AsStringPiece());
+ stream->OnCryptoFrame(frame);
+ }
+}
+
+void CommunicateHandshakeMessages(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server) {
+ size_t client_i = 0, server_i = 0;
+ while (client_conn->connected() && server_conn->connected() &&
+ (!client->one_rtt_keys_available() ||
+ !server->one_rtt_keys_available())) {
+ ASSERT_GT(client_conn->encrypted_packets_.size(), client_i);
+ QUIC_LOG(INFO) << "Processing "
+ << client_conn->encrypted_packets_.size() - client_i
+ << " packets client->server";
+ MovePackets(client_conn, &client_i, server, server_conn,
+ Perspective::IS_SERVER);
+
+ if (client->one_rtt_keys_available() && server->one_rtt_keys_available() &&
+ server_conn->encrypted_packets_.size() == server_i) {
+ break;
+ }
+ ASSERT_GT(server_conn->encrypted_packets_.size(), server_i);
+ QUIC_LOG(INFO) << "Processing "
+ << server_conn->encrypted_packets_.size() - server_i
+ << " packets server->client";
+ MovePackets(server_conn, &server_i, client, client_conn,
+ Perspective::IS_CLIENT);
+ }
+}
+
+bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ std::function<bool()> client_condition,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server,
+ std::function<bool()> server_condition) {
+ size_t client_next_packet_to_deliver =
+ client_conn->number_of_packets_delivered_;
+ size_t server_next_packet_to_deliver =
+ server_conn->number_of_packets_delivered_;
+ while (
+ client_conn->connected() && server_conn->connected() &&
+ (!client_condition() || !server_condition()) &&
+ (client_conn->encrypted_packets_.size() > client_next_packet_to_deliver ||
+ server_conn->encrypted_packets_.size() >
+ server_next_packet_to_deliver)) {
+ if (!server_condition()) {
+ QUIC_LOG(INFO) << "Processing "
+ << client_conn->encrypted_packets_.size() -
+ client_next_packet_to_deliver
+ << " packets client->server";
+ MovePackets(client_conn, &client_next_packet_to_deliver, server,
+ server_conn, Perspective::IS_SERVER);
+ }
+ if (!client_condition()) {
+ QUIC_LOG(INFO) << "Processing "
+ << server_conn->encrypted_packets_.size() -
+ server_next_packet_to_deliver
+ << " packets server->client";
+ MovePackets(server_conn, &server_next_packet_to_deliver, client,
+ client_conn, Perspective::IS_CLIENT);
+ }
+ }
+ client_conn->number_of_packets_delivered_ = client_next_packet_to_deliver;
+ server_conn->number_of_packets_delivered_ = server_next_packet_to_deliver;
+ bool result = client_condition() && server_condition();
+ if (!result) {
+ QUIC_LOG(INFO) << "CommunicateHandshakeMessagesUnti failed with state: "
+ "client connected? "
+ << client_conn->connected() << " server connected? "
+ << server_conn->connected() << " client condition met? "
+ << client_condition() << " server condition met? "
+ << server_condition();
+ }
+ return result;
+}
+
+std::pair<size_t, size_t> AdvanceHandshake(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ size_t client_i,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server,
+ size_t server_i) {
+ if (client_conn->encrypted_packets_.size() != client_i) {
+ QUIC_LOG(INFO) << "Processing "
+ << client_conn->encrypted_packets_.size() - client_i
+ << " packets client->server";
+ MovePackets(client_conn, &client_i, server, server_conn,
+ Perspective::IS_SERVER);
+ }
+
+ if (server_conn->encrypted_packets_.size() != server_i) {
+ QUIC_LOG(INFO) << "Processing "
+ << server_conn->encrypted_packets_.size() - server_i
+ << " packets server->client";
+ MovePackets(server_conn, &server_i, client, client_conn,
+ Perspective::IS_CLIENT);
+ }
+
+ return std::make_pair(client_i, server_i);
+}
+
+std::string GetValueForTag(const CryptoHandshakeMessage& message, QuicTag tag) {
+ auto it = message.tag_value_map().find(tag);
+ if (it == message.tag_value_map().end()) {
+ return std::string();
+ }
+ return it->second;
+}
+
+uint64_t LeafCertHashForTesting() {
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain;
+ QuicSocketAddress server_address(QuicIpAddress::Any4(), 42);
+ QuicSocketAddress client_address(QuicIpAddress::Any4(), 43);
+ QuicCryptoProof proof;
+ std::unique_ptr<ProofSource> proof_source(ProofSourceForTesting());
+
+ class Callback : public ProofSource::Callback {
+ public:
+ Callback(bool* ok,
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain>* chain)
+ : ok_(ok), chain_(chain) {}
+
+ void Run(
+ bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const QuicCryptoProof& /* proof */,
+ std::unique_ptr<ProofSource::Details> /* details */) override {
+ *ok_ = ok;
+ *chain_ = chain;
+ }
+
+ private:
+ bool* ok_;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain>* chain_;
+ };
+
+ // Note: relies on the callback being invoked synchronously
+ bool ok = false;
+ proof_source->GetProof(
+ server_address, client_address, "", "",
+ AllSupportedVersionsWithQuicCrypto().front().transport_version, "",
+ std::unique_ptr<ProofSource::Callback>(new Callback(&ok, &chain)));
+ if (!ok || chain->certs.empty()) {
+ QUICHE_DCHECK(false) << "Proof generation failed";
+ return 0;
+ }
+
+ return QuicUtils::FNV1a_64_Hash(chain->certs.at(0));
+}
+
+void FillInDummyReject(CryptoHandshakeMessage* rej) {
+ rej->set_tag(kREJ);
+
+ // Minimum SCFG that passes config validation checks.
+ // clang-format off
+ unsigned char scfg[] = {
+ // SCFG
+ 0x53, 0x43, 0x46, 0x47,
+ // num entries
+ 0x01, 0x00,
+ // padding
+ 0x00, 0x00,
+ // EXPY
+ 0x45, 0x58, 0x50, 0x59,
+ // EXPY end offset
+ 0x08, 0x00, 0x00, 0x00,
+ // Value
+ '1', '2', '3', '4',
+ '5', '6', '7', '8'
+ };
+ // clang-format on
+ rej->SetValue(kSCFG, scfg);
+ rej->SetStringPiece(kServerNonceTag, "SERVER_NONCE");
+ int64_t ttl = 2 * 24 * 60 * 60;
+ rej->SetValue(kSTTL, ttl);
+ std::vector<QuicTag> reject_reasons;
+ reject_reasons.push_back(CLIENT_NONCE_INVALID_FAILURE);
+ rej->SetVector(kRREJ, reject_reasons);
+}
+
+namespace {
+
+#define RETURN_STRING_LITERAL(x) \
+ case x: \
+ return #x
+
+std::string EncryptionLevelString(EncryptionLevel level) {
+ switch (level) {
+ RETURN_STRING_LITERAL(ENCRYPTION_INITIAL);
+ RETURN_STRING_LITERAL(ENCRYPTION_HANDSHAKE);
+ RETURN_STRING_LITERAL(ENCRYPTION_ZERO_RTT);
+ RETURN_STRING_LITERAL(ENCRYPTION_FORWARD_SECURE);
+ default:
+ return "";
+ }
+}
+
+void CompareCrypters(const QuicEncrypter* encrypter,
+ const QuicDecrypter* decrypter,
+ std::string label) {
+ if (encrypter == nullptr || decrypter == nullptr) {
+ ADD_FAILURE() << "Expected non-null crypters; have " << encrypter << " and "
+ << decrypter << " for " << label;
+ return;
+ }
+ absl::string_view encrypter_key = encrypter->GetKey();
+ absl::string_view encrypter_iv = encrypter->GetNoncePrefix();
+ absl::string_view decrypter_key = decrypter->GetKey();
+ absl::string_view decrypter_iv = decrypter->GetNoncePrefix();
+ quiche::test::CompareCharArraysWithHexError(
+ label + " key", encrypter_key.data(), encrypter_key.length(),
+ decrypter_key.data(), decrypter_key.length());
+ quiche::test::CompareCharArraysWithHexError(
+ label + " iv", encrypter_iv.data(), encrypter_iv.length(),
+ decrypter_iv.data(), decrypter_iv.length());
+}
+
+} // namespace
+
+void CompareClientAndServerKeys(QuicCryptoClientStreamBase* client,
+ QuicCryptoServerStreamBase* server) {
+ QuicFramer* client_framer = QuicConnectionPeer::GetFramer(
+ QuicStreamPeer::session(client)->connection());
+ QuicFramer* server_framer = QuicConnectionPeer::GetFramer(
+ QuicStreamPeer::session(server)->connection());
+ for (EncryptionLevel level :
+ {ENCRYPTION_HANDSHAKE, ENCRYPTION_ZERO_RTT, ENCRYPTION_FORWARD_SECURE}) {
+ SCOPED_TRACE(EncryptionLevelString(level));
+ const QuicEncrypter* client_encrypter(
+ QuicFramerPeer::GetEncrypter(client_framer, level));
+ const QuicDecrypter* server_decrypter(
+ QuicFramerPeer::GetDecrypter(server_framer, level));
+ if (level == ENCRYPTION_FORWARD_SECURE ||
+ !((level == ENCRYPTION_HANDSHAKE || level == ENCRYPTION_ZERO_RTT ||
+ client_encrypter == nullptr) &&
+ (level == ENCRYPTION_ZERO_RTT || server_decrypter == nullptr))) {
+ CompareCrypters(client_encrypter, server_decrypter,
+ "client " + EncryptionLevelString(level) + " write");
+ }
+ const QuicEncrypter* server_encrypter(
+ QuicFramerPeer::GetEncrypter(server_framer, level));
+ const QuicDecrypter* client_decrypter(
+ QuicFramerPeer::GetDecrypter(client_framer, level));
+ if (level == ENCRYPTION_FORWARD_SECURE ||
+ !(server_encrypter == nullptr &&
+ (level == ENCRYPTION_HANDSHAKE || level == ENCRYPTION_ZERO_RTT ||
+ client_decrypter == nullptr))) {
+ CompareCrypters(server_encrypter, client_decrypter,
+ "server " + EncryptionLevelString(level) + " write");
+ }
+ }
+
+ absl::string_view client_subkey_secret =
+ client->crypto_negotiated_params().subkey_secret;
+ absl::string_view server_subkey_secret =
+ server->crypto_negotiated_params().subkey_secret;
+ quiche::test::CompareCharArraysWithHexError(
+ "subkey secret", client_subkey_secret.data(),
+ client_subkey_secret.length(), server_subkey_secret.data(),
+ server_subkey_secret.length());
+}
+
+QuicTag ParseTag(const char* tagstr) {
+ const size_t len = strlen(tagstr);
+ QUICHE_CHECK_NE(0u, len);
+
+ QuicTag tag = 0;
+
+ if (tagstr[0] == '#') {
+ QUICHE_CHECK_EQ(static_cast<size_t>(1 + 2 * 4), len);
+ tagstr++;
+
+ for (size_t i = 0; i < 8; i++) {
+ tag <<= 4;
+
+ uint8_t v = 0;
+ QUICHE_CHECK(HexChar(tagstr[i], &v));
+ tag |= v;
+ }
+
+ return tag;
+ }
+
+ QUICHE_CHECK_LE(len, 4u);
+ for (size_t i = 0; i < 4; i++) {
+ tag >>= 8;
+ if (i < len) {
+ tag |= static_cast<uint32_t>(tagstr[i]) << 24;
+ }
+ }
+
+ return tag;
+}
+
+CryptoHandshakeMessage CreateCHLO(
+ std::vector<std::pair<std::string, std::string>> tags_and_values) {
+ return CreateCHLO(tags_and_values, -1);
+}
+
+CryptoHandshakeMessage CreateCHLO(
+ std::vector<std::pair<std::string, std::string>> tags_and_values,
+ int minimum_size_bytes) {
+ CryptoHandshakeMessage msg;
+ msg.set_tag(MakeQuicTag('C', 'H', 'L', 'O'));
+
+ if (minimum_size_bytes > 0) {
+ msg.set_minimum_size(minimum_size_bytes);
+ }
+
+ for (const auto& tag_and_value : tags_and_values) {
+ const std::string& tag = tag_and_value.first;
+ const std::string& value = tag_and_value.second;
+
+ const QuicTag quic_tag = ParseTag(tag.c_str());
+
+ size_t value_len = value.length();
+ if (value_len > 0 && value[0] == '#') {
+ // This is ascii encoded hex.
+ std::string hex_value =
+ absl::HexStringToBytes(absl::string_view(&value[1]));
+ msg.SetStringPiece(quic_tag, hex_value);
+ continue;
+ }
+ msg.SetStringPiece(quic_tag, value);
+ }
+
+ // The CryptoHandshakeMessage needs to be serialized and parsed to ensure
+ // that any padding is included.
+ std::unique_ptr<QuicData> bytes =
+ CryptoFramer::ConstructHandshakeMessage(msg);
+ std::unique_ptr<CryptoHandshakeMessage> parsed(
+ CryptoFramer::ParseMessage(bytes->AsStringPiece()));
+ QUICHE_CHECK(parsed);
+
+ return *parsed;
+}
+
+void MovePackets(PacketSavingConnection* source_conn,
+ size_t* inout_packet_index,
+ QuicCryptoStream* dest_stream,
+ PacketSavingConnection* dest_conn,
+ Perspective dest_perspective) {
+ SimpleQuicFramer framer(source_conn->supported_versions(), dest_perspective);
+ QuicFramerPeer::SetLastSerializedServerConnectionId(framer.framer(),
+ TestConnectionId());
+
+ SimpleQuicFramer null_encryption_framer(source_conn->supported_versions(),
+ dest_perspective);
+ QuicFramerPeer::SetLastSerializedServerConnectionId(
+ null_encryption_framer.framer(), TestConnectionId());
+
+ size_t index = *inout_packet_index;
+ for (; index < source_conn->encrypted_packets_.size(); index++) {
+ if (!dest_conn->connected()) {
+ QUIC_LOG(INFO)
+ << "Destination connection disconnected. Skipping packet at index "
+ << index;
+ continue;
+ }
+ // In order to properly test the code we need to perform encryption and
+ // decryption so that the crypters latch when expected. The crypters are in
+ // |dest_conn|, but we don't want to try and use them there. Instead we swap
+ // them into |framer|, perform the decryption with them, and then swap ther
+ // back.
+ QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
+ QuicConnectionPeer::AddBytesReceived(
+ dest_conn, source_conn->encrypted_packets_[index]->length());
+ if (!framer.ProcessPacket(*source_conn->encrypted_packets_[index])) {
+ // The framer will be unable to decrypt zero-rtt packets sent during
+ // handshake or forward-secure packets sent after the handshake is
+ // complete. Don't treat them as handshake packets.
+ QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
+ continue;
+ }
+ QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
+
+ // Install a packet flusher such that the packets generated by |dest_conn|
+ // in response to this packet are more likely to be coalesced and/or batched
+ // in the writer.
+ QuicConnection::ScopedPacketFlusher flusher(dest_conn);
+
+ dest_conn->OnDecryptedPacket(
+ source_conn->encrypted_packets_[index]->length(),
+ framer.last_decrypted_level());
+
+ if (dest_stream->handshake_protocol() == PROTOCOL_TLS1_3) {
+ // Try to process the packet with a framer that only has the NullDecrypter
+ // for decryption. If ProcessPacket succeeds, that means the packet was
+ // encrypted with the NullEncrypter. With the TLS handshaker in use, no
+ // packets should ever be encrypted with the NullEncrypter, instead
+ // they're encrypted with an obfuscation cipher based on QUIC version and
+ // connection ID.
+ QUIC_LOG(INFO) << "Attempting to decrypt with NullDecrypter: "
+ "expect a decryption failure on the next log line.";
+ ASSERT_FALSE(null_encryption_framer.ProcessPacket(
+ *source_conn->encrypted_packets_[index]))
+ << "No TLS packets should be encrypted with the NullEncrypter";
+ }
+
+ // Since we're using QuicFramers separate from the connections to move
+ // packets, the QuicConnection never gets notified about what level the last
+ // packet was decrypted at. This is needed by TLS to know what encryption
+ // level was used for the data it's receiving, so we plumb this information
+ // from the SimpleQuicFramer back into the connection.
+ dest_conn->OnDecryptedPacket(
+ source_conn->encrypted_packets_[index]->length(),
+ framer.last_decrypted_level());
+
+ QuicConnectionPeer::SetCurrentPacket(
+ dest_conn, source_conn->encrypted_packets_[index]->AsStringPiece());
+ for (const auto& stream_frame : framer.stream_frames()) {
+ // Ignore stream frames that are sent on other streams in the crypto
+ // event.
+ if (stream_frame->stream_id == dest_stream->id()) {
+ dest_stream->OnStreamFrame(*stream_frame);
+ }
+ }
+ for (const auto& crypto_frame : framer.crypto_frames()) {
+ dest_stream->OnCryptoFrame(*crypto_frame);
+ }
+ if (!framer.connection_close_frames().empty() && dest_conn->connected()) {
+ dest_conn->OnConnectionCloseFrame(framer.connection_close_frames()[0]);
+ }
+ }
+ *inout_packet_index = index;
+
+ QuicConnectionPeer::SetCurrentPacket(dest_conn,
+ absl::string_view(nullptr, 0));
+}
+
+CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
+ const QuicClock* clock,
+ QuicTransportVersion version,
+ QuicCryptoServerConfig* crypto_config) {
+ // clang-format off
+ return CreateCHLO(
+ {{"PDMD", "X509"},
+ {"AEAD", "AESG"},
+ {"KEXS", "C255"},
+ {"PUBS", GenerateClientPublicValuesHex().c_str()},
+ {"NONC", GenerateClientNonceHex(clock, crypto_config).c_str()},
+ {"VER\0", QuicVersionLabelToString(
+ CreateQuicVersionLabel(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version))).c_str()}},
+ kClientHelloMinimumSize);
+ // clang-format on
+}
+
+std::string GenerateClientNonceHex(const QuicClock* clock,
+ QuicCryptoServerConfig* crypto_config) {
+ QuicCryptoServerConfig::ConfigOptions old_config_options;
+ QuicCryptoServerConfig::ConfigOptions new_config_options;
+ old_config_options.id = "old-config-id";
+ crypto_config->AddDefaultConfig(QuicRandom::GetInstance(), clock,
+ old_config_options);
+ QuicServerConfigProtobuf primary_config = crypto_config->GenerateConfig(
+ QuicRandom::GetInstance(), clock, new_config_options);
+ primary_config.set_primary_time(clock->WallNow().ToUNIXSeconds());
+ std::unique_ptr<CryptoHandshakeMessage> msg =
+ crypto_config->AddConfig(primary_config, clock->WallNow());
+ absl::string_view orbit;
+ QUICHE_CHECK(msg->GetStringPiece(kORBT, &orbit));
+ std::string nonce;
+ CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
+ &nonce);
+ return ("#" + absl::BytesToHexString(nonce));
+}
+
+std::string GenerateClientPublicValuesHex() {
+ char public_value[32];
+ memset(public_value, 42, sizeof(public_value));
+ return ("#" + absl::BytesToHexString(
+ absl::string_view(public_value, sizeof(public_value))));
+}
+
+void GenerateFullCHLO(
+ const CryptoHandshakeMessage& inchoate_chlo,
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, QuicTransportVersion transport_version,
+ const QuicClock* clock,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ CryptoHandshakeMessage* out) {
+ // Pass a inchoate CHLO.
+ FullChloGenerator generator(
+ crypto_config, server_addr, client_addr, clock,
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version), signed_config,
+ compressed_certs_cache, out);
+ crypto_config->ValidateClientHello(
+ inchoate_chlo, client_addr, server_addr, transport_version, clock,
+ signed_config, generator.GetValidateClientHelloCallback());
+}
+
+} // namespace crypto_test_utils
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/crypto_test_utils.h b/quiche/quic/test_tools/crypto_test_utils.h
new file mode 100644
index 0000000..b54d447
--- /dev/null
+++ b/quiche/quic/test_tools/crypto_test_utils.h
@@ -0,0 +1,218 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
+
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "third_party/boringssl/src/include/openssl/evp.h"
+#include "quiche/quic/core/crypto/crypto_framer.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+
+class ProofSource;
+class ProofVerifier;
+class ProofVerifyContext;
+class QuicClock;
+class QuicConfig;
+class QuicCryptoClientStream;
+class QuicCryptoServerConfig;
+class QuicCryptoServerStreamBase;
+class QuicCryptoStream;
+class QuicRandom;
+class QuicServerId;
+
+namespace test {
+
+class PacketSavingConnection;
+
+namespace crypto_test_utils {
+
+// An interface for a source of callbacks. This is used for invoking
+// callbacks asynchronously.
+//
+// Call the RunPendingCallbacks method regularly to run the callbacks from
+// this source.
+class CallbackSource {
+ public:
+ virtual ~CallbackSource() {}
+
+ // Runs pending callbacks from this source. If there is no pending
+ // callback, does nothing.
+ virtual void RunPendingCallbacks() = 0;
+};
+
+// FakeClientOptions bundles together a number of options for configuring
+// HandshakeWithFakeClient.
+struct FakeClientOptions {
+ FakeClientOptions();
+ ~FakeClientOptions();
+
+ // If only_tls_versions is set, then the client will only use TLS for the
+ // crypto handshake.
+ bool only_tls_versions = false;
+
+ // If only_quic_crypto_versions is set, then the client will only use
+ // PROTOCOL_QUIC_CRYPTO for the crypto handshake.
+ bool only_quic_crypto_versions = false;
+};
+
+// Returns a QuicCryptoServerConfig that is in a reasonable configuration to
+// pass into HandshakeWithFakeServer.
+std::unique_ptr<QuicCryptoServerConfig> CryptoServerConfigForTesting();
+
+// returns: the number of client hellos that the client sent.
+int HandshakeWithFakeServer(QuicConfig* server_quic_config,
+ QuicCryptoServerConfig* crypto_config,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ PacketSavingConnection* client_conn,
+ QuicCryptoClientStreamBase* client,
+ std::string alpn);
+
+// returns: the number of client hellos that the client sent.
+int HandshakeWithFakeClient(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ PacketSavingConnection* server_conn,
+ QuicCryptoServerStreamBase* server,
+ const QuicServerId& server_id,
+ const FakeClientOptions& options,
+ std::string alpn);
+
+// SetupCryptoServerConfigForTest configures |crypto_config|
+// with sensible defaults for testing.
+void SetupCryptoServerConfigForTest(const QuicClock* clock,
+ QuicRandom* rand,
+ QuicCryptoServerConfig* crypto_config);
+
+// Sends the handshake message |message| to stream |stream| with the perspective
+// that the message is coming from |perspective|.
+void SendHandshakeMessageToStream(QuicCryptoStream* stream,
+ const CryptoHandshakeMessage& message,
+ Perspective perspective);
+
+// CommunicateHandshakeMessages moves messages from |client| to |server| and
+// back until |clients|'s handshake has completed.
+void CommunicateHandshakeMessages(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server);
+
+// CommunicateHandshakeMessagesUntil:
+// 1) Moves messages from |client| to |server| until |server_condition| is met.
+// 2) Moves messages from |server| to |client| until |client_condition| is met.
+// 3) Returns true if both conditions are met.
+// 4) Returns false if either connection is closed or there is no more packet to
+// deliver before both conditions are met.
+bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ std::function<bool()> client_condition,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server,
+ std::function<bool()> server_condition);
+
+// AdvanceHandshake attempts to moves messages from |client| to |server| and
+// |server| to |client|. Returns the number of messages moved.
+std::pair<size_t, size_t> AdvanceHandshake(PacketSavingConnection* client_conn,
+ QuicCryptoStream* client,
+ size_t client_i,
+ PacketSavingConnection* server_conn,
+ QuicCryptoStream* server,
+ size_t server_i);
+
+// Returns the value for the tag |tag| in the tag value map of |message|.
+std::string GetValueForTag(const CryptoHandshakeMessage& message, QuicTag tag);
+
+// Returns a new |ProofSource| that serves up test certificates.
+std::unique_ptr<ProofSource> ProofSourceForTesting();
+
+// Returns a new |ProofVerifier| that uses the QUIC testing root CA.
+std::unique_ptr<ProofVerifier> ProofVerifierForTesting();
+
+// Returns a hash of the leaf test certificate.
+uint64_t LeafCertHashForTesting();
+
+// Returns a |ProofVerifyContext| that must be used with the verifier
+// returned by |ProofVerifierForTesting|.
+std::unique_ptr<ProofVerifyContext> ProofVerifyContextForTesting();
+
+// Creates a minimal dummy reject message that will pass the client-config
+// validation tests. This will include a server config, but no certs, proof
+// source address token, or server nonce.
+void FillInDummyReject(CryptoHandshakeMessage* rej);
+
+// ParseTag returns a QuicTag from parsing |tagstr|. |tagstr| may either be
+// in the format "EXMP" (i.e. ASCII format), or "#11223344" (an explicit hex
+// format). It QUICHE_CHECK fails if there's a parse error.
+QuicTag ParseTag(const char* tagstr);
+
+// Message constructs a CHLO message from a provided vector of tag/value pairs.
+// The first of each pair is the tag of a tag/value and is given as an argument
+// to |ParseTag|. The second is the value of the tag/value pair and is either a
+// hex dump, preceeded by a '#', or a raw value. If minimum_size_bytes is
+// provided then the message will be padded to this minimum size.
+//
+// CreateCHLO(
+// {{"NOCE", "#11223344"},
+// {"SNI", "www.example.com"}},
+// optional_minimum_size_bytes);
+CryptoHandshakeMessage CreateCHLO(
+ std::vector<std::pair<std::string, std::string>> tags_and_values);
+CryptoHandshakeMessage CreateCHLO(
+ std::vector<std::pair<std::string, std::string>> tags_and_values,
+ int minimum_size_bytes);
+
+// MovePackets parses crypto handshake messages from packet number
+// |*inout_packet_index| through to the last packet (or until a packet fails
+// to decrypt) and has |dest_stream| process them. |*inout_packet_index| is
+// updated with an index one greater than the last packet processed.
+void MovePackets(PacketSavingConnection* source_conn,
+ size_t* inout_packet_index,
+ QuicCryptoStream* dest_stream,
+ PacketSavingConnection* dest_conn,
+ Perspective dest_perspective);
+
+// Return an inchoate CHLO with some basic tag value pairs.
+CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
+ const QuicClock* clock,
+ QuicTransportVersion version,
+ QuicCryptoServerConfig* crypto_config);
+
+// Takes a inchoate CHLO, returns a full CHLO in |out| which can pass
+// |crypto_config|'s validation.
+void GenerateFullCHLO(
+ const CryptoHandshakeMessage& inchoate_chlo,
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, QuicTransportVersion transport_version,
+ const QuicClock* clock,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ CryptoHandshakeMessage* out);
+
+void CompareClientAndServerKeys(QuicCryptoClientStreamBase* client,
+ QuicCryptoServerStreamBase* server);
+
+// Return a CHLO nonce in hexadecimal.
+std::string GenerateClientNonceHex(const QuicClock* clock,
+ QuicCryptoServerConfig* crypto_config);
+
+// Return a CHLO PUBS in hexadecimal.
+std::string GenerateClientPublicValuesHex();
+
+} // namespace crypto_test_utils
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/crypto_test_utils_test.cc b/quiche/quic/test_tools/crypto_test_utils_test.cc
new file mode 100644
index 0000000..200f5be
--- /dev/null
+++ b/quiche/quic/test_tools/crypto_test_utils_test.cc
@@ -0,0 +1,188 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+
+#include <utility>
+
+#include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/proto/crypto_server_config_proto.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_clock.h"
+
+namespace quic {
+namespace test {
+
+class ShloVerifier {
+ public:
+ ShloVerifier(QuicCryptoServerConfig* crypto_config,
+ QuicSocketAddress server_addr, QuicSocketAddress client_addr,
+ const QuicClock* clock,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ ParsedQuicVersion version)
+ : crypto_config_(crypto_config),
+ server_addr_(server_addr),
+ client_addr_(client_addr),
+ clock_(clock),
+ signed_config_(signed_config),
+ compressed_certs_cache_(compressed_certs_cache),
+ params_(new QuicCryptoNegotiatedParameters),
+ version_(version) {}
+
+ class ValidateClientHelloCallback : public ValidateClientHelloResultCallback {
+ public:
+ explicit ValidateClientHelloCallback(ShloVerifier* shlo_verifier)
+ : shlo_verifier_(shlo_verifier) {}
+ void Run(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result,
+ std::unique_ptr<ProofSource::Details> /* details */) override {
+ shlo_verifier_->ValidateClientHelloDone(result);
+ }
+
+ private:
+ ShloVerifier* shlo_verifier_;
+ };
+
+ std::unique_ptr<ValidateClientHelloCallback>
+ GetValidateClientHelloCallback() {
+ return std::make_unique<ValidateClientHelloCallback>(this);
+ }
+
+ private:
+ void ValidateClientHelloDone(
+ const quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>& result) {
+ result_ = result;
+ crypto_config_->ProcessClientHello(
+ result_, /*reject_only=*/false,
+ /*connection_id=*/TestConnectionId(1), server_addr_, client_addr_,
+ version_, AllSupportedVersions(), clock_, QuicRandom::GetInstance(),
+ compressed_certs_cache_, params_, signed_config_,
+ /*total_framing_overhead=*/50, kDefaultMaxPacketSize,
+ GetProcessClientHelloCallback());
+ }
+
+ class ProcessClientHelloCallback : public ProcessClientHelloResultCallback {
+ public:
+ explicit ProcessClientHelloCallback(ShloVerifier* shlo_verifier)
+ : shlo_verifier_(shlo_verifier) {}
+ void Run(QuicErrorCode /*error*/,
+ const std::string& /*error_details*/,
+ std::unique_ptr<CryptoHandshakeMessage> message,
+ std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
+ std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
+ override {
+ shlo_verifier_->ProcessClientHelloDone(std::move(message));
+ }
+
+ private:
+ ShloVerifier* shlo_verifier_;
+ };
+
+ std::unique_ptr<ProcessClientHelloCallback> GetProcessClientHelloCallback() {
+ return std::make_unique<ProcessClientHelloCallback>(this);
+ }
+
+ void ProcessClientHelloDone(std::unique_ptr<CryptoHandshakeMessage> message) {
+ // Verify output is a SHLO.
+ EXPECT_EQ(message->tag(), kSHLO)
+ << "Fail to pass validation. Get " << message->DebugString();
+ }
+
+ QuicCryptoServerConfig* crypto_config_;
+ QuicSocketAddress server_addr_;
+ QuicSocketAddress client_addr_;
+ const QuicClock* clock_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ QuicCompressedCertsCache* compressed_certs_cache_;
+
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result_;
+
+ const ParsedQuicVersion version_;
+};
+
+class CryptoTestUtilsTest : public QuicTest {};
+
+TEST_F(CryptoTestUtilsTest, TestGenerateFullCHLO) {
+ MockClock clock;
+ QuicCryptoServerConfig crypto_config(
+ QuicCryptoServerConfig::TESTING, QuicRandom::GetInstance(),
+ crypto_test_utils::ProofSourceForTesting(), KeyExchangeSource::Default());
+ QuicSocketAddress server_addr(QuicIpAddress::Any4(), 5);
+ QuicSocketAddress client_addr(QuicIpAddress::Loopback4(), 1);
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config(
+ new QuicSignedServerConfig);
+ QuicCompressedCertsCache compressed_certs_cache(
+ QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
+ CryptoHandshakeMessage full_chlo;
+
+ QuicCryptoServerConfig::ConfigOptions old_config_options;
+ old_config_options.id = "old-config-id";
+ crypto_config.AddDefaultConfig(QuicRandom::GetInstance(), &clock,
+ old_config_options);
+ QuicCryptoServerConfig::ConfigOptions new_config_options;
+ QuicServerConfigProtobuf primary_config = crypto_config.GenerateConfig(
+ QuicRandom::GetInstance(), &clock, new_config_options);
+ primary_config.set_primary_time(clock.WallNow().ToUNIXSeconds());
+ std::unique_ptr<CryptoHandshakeMessage> msg =
+ crypto_config.AddConfig(primary_config, clock.WallNow());
+ absl::string_view orbit;
+ ASSERT_TRUE(msg->GetStringPiece(kORBT, &orbit));
+ std::string nonce;
+ CryptoUtils::GenerateNonce(clock.WallNow(), QuicRandom::GetInstance(), orbit,
+ &nonce);
+ std::string nonce_hex = "#" + absl::BytesToHexString(nonce);
+
+ char public_value[32];
+ memset(public_value, 42, sizeof(public_value));
+ std::string pub_hex = "#" + absl::BytesToHexString(absl::string_view(
+ public_value, sizeof(public_value)));
+
+ // The methods below use a PROTOCOL_QUIC_CRYPTO version so we pick the
+ // first one from the list of supported versions.
+ QuicTransportVersion transport_version = QUIC_VERSION_UNSUPPORTED;
+ for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+ if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+ transport_version = version.transport_version;
+ break;
+ }
+ }
+ ASSERT_NE(QUIC_VERSION_UNSUPPORTED, transport_version);
+
+ CryptoHandshakeMessage inchoate_chlo = crypto_test_utils::CreateCHLO(
+ {{"PDMD", "X509"},
+ {"AEAD", "AESG"},
+ {"KEXS", "C255"},
+ {"COPT", "SREJ"},
+ {"PUBS", pub_hex},
+ {"NONC", nonce_hex},
+ {"VER\0",
+ QuicVersionLabelToString(CreateQuicVersionLabel(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version)))}},
+ kClientHelloMinimumSize);
+
+ crypto_test_utils::GenerateFullCHLO(inchoate_chlo, &crypto_config,
+ server_addr, client_addr,
+ transport_version, &clock, signed_config,
+ &compressed_certs_cache, &full_chlo);
+ // Verify that full_chlo can pass crypto_config's verification.
+ ShloVerifier shlo_verifier(
+ &crypto_config, server_addr, client_addr, &clock, signed_config,
+ &compressed_certs_cache,
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version));
+ crypto_config.ValidateClientHello(
+ full_chlo, client_addr, server_addr, transport_version, &clock,
+ signed_config, shlo_verifier.GetValidateClientHelloCallback());
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/failing_proof_source.cc b/quiche/quic/test_tools/failing_proof_source.cc
new file mode 100644
index 0000000..b16ef50
--- /dev/null
+++ b/quiche/quic/test_tools/failing_proof_source.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/failing_proof_source.h"
+
+#include "absl/strings/string_view.h"
+
+namespace quic {
+namespace test {
+
+void FailingProofSource::GetProof(const QuicSocketAddress& /*server_address*/,
+ const QuicSocketAddress& /*client_address*/,
+ const std::string& /*hostname*/,
+ const std::string& /*server_config*/,
+ QuicTransportVersion /*transport_version*/,
+ absl::string_view /*chlo_hash*/,
+ std::unique_ptr<Callback> callback) {
+ callback->Run(false, nullptr, QuicCryptoProof(), nullptr);
+}
+
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain>
+FailingProofSource::GetCertChain(const QuicSocketAddress& /*server_address*/,
+ const QuicSocketAddress& /*client_address*/,
+ const std::string& /*hostname*/,
+ bool* cert_matched_sni) {
+ *cert_matched_sni = false;
+ return quiche::QuicheReferenceCountedPointer<Chain>();
+}
+
+void FailingProofSource::ComputeTlsSignature(
+ const QuicSocketAddress& /*server_address*/,
+ const QuicSocketAddress& /*client_address*/,
+ const std::string& /*hostname*/,
+ uint16_t /*signature_algorithm*/,
+ absl::string_view /*in*/,
+ std::unique_ptr<SignatureCallback> callback) {
+ callback->Run(false, "", nullptr);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/failing_proof_source.h b/quiche/quic/test_tools/failing_proof_source.h
new file mode 100644
index 0000000..6ab29ac
--- /dev/null
+++ b/quiche/quic/test_tools/failing_proof_source.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
+#define QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/proof_source.h"
+
+namespace quic {
+namespace test {
+
+class FailingProofSource : public ProofSource {
+ public:
+ void GetProof(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ const std::string& server_config,
+ QuicTransportVersion transport_version,
+ absl::string_view chlo_hash,
+ std::unique_ptr<Callback> callback) override;
+
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ bool* cert_matched_sni) override;
+
+ void ComputeTlsSignature(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ std::unique_ptr<SignatureCallback> callback) override;
+
+ absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
+ const override {
+ return {};
+ }
+
+ TicketCrypter* GetTicketCrypter() override { return nullptr; }
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
diff --git a/quiche/quic/test_tools/fake_proof_source.cc b/quiche/quic/test_tools/fake_proof_source.cc
new file mode 100644
index 0000000..8ae9592
--- /dev/null
+++ b/quiche/quic/test_tools/fake_proof_source.cc
@@ -0,0 +1,159 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/fake_proof_source.h"
+
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+
+namespace quic {
+namespace test {
+
+FakeProofSource::FakeProofSource()
+ : delegate_(crypto_test_utils::ProofSourceForTesting()) {}
+
+FakeProofSource::~FakeProofSource() {}
+
+FakeProofSource::PendingOp::~PendingOp() = default;
+
+FakeProofSource::GetProofOp::GetProofOp(
+ const QuicSocketAddress& server_addr,
+ const QuicSocketAddress& client_address,
+ std::string hostname,
+ std::string server_config,
+ QuicTransportVersion transport_version,
+ std::string chlo_hash,
+ std::unique_ptr<ProofSource::Callback> callback,
+ ProofSource* delegate)
+ : server_address_(server_addr),
+ client_address_(client_address),
+ hostname_(std::move(hostname)),
+ server_config_(std::move(server_config)),
+ transport_version_(transport_version),
+ chlo_hash_(std::move(chlo_hash)),
+ callback_(std::move(callback)),
+ delegate_(delegate) {}
+
+FakeProofSource::GetProofOp::~GetProofOp() = default;
+
+void FakeProofSource::GetProofOp::Run() {
+ // Note: relies on the callback being invoked synchronously
+ delegate_->GetProof(server_address_, client_address_, hostname_,
+ server_config_, transport_version_, chlo_hash_,
+ std::move(callback_));
+}
+
+FakeProofSource::ComputeSignatureOp::ComputeSignatureOp(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ std::string hostname,
+ uint16_t sig_alg,
+ absl::string_view in,
+ std::unique_ptr<ProofSource::SignatureCallback> callback,
+ ProofSource* delegate)
+ : server_address_(server_address),
+ client_address_(client_address),
+ hostname_(std::move(hostname)),
+ sig_alg_(sig_alg),
+ in_(in),
+ callback_(std::move(callback)),
+ delegate_(delegate) {}
+
+FakeProofSource::ComputeSignatureOp::~ComputeSignatureOp() = default;
+
+void FakeProofSource::ComputeSignatureOp::Run() {
+ delegate_->ComputeTlsSignature(server_address_, client_address_, hostname_,
+ sig_alg_, in_, std::move(callback_));
+}
+
+void FakeProofSource::Activate() {
+ active_ = true;
+}
+
+void FakeProofSource::GetProof(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ const std::string& server_config,
+ QuicTransportVersion transport_version,
+ absl::string_view chlo_hash,
+ std::unique_ptr<ProofSource::Callback> callback) {
+ if (!active_) {
+ delegate_->GetProof(server_address, client_address, hostname, server_config,
+ transport_version, chlo_hash, std::move(callback));
+ return;
+ }
+
+ pending_ops_.push_back(std::make_unique<GetProofOp>(
+ server_address, client_address, hostname, server_config,
+ transport_version, std::string(chlo_hash), std::move(callback),
+ delegate_.get()));
+}
+
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain>
+FakeProofSource::GetCertChain(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ bool* cert_matched_sni) {
+ return delegate_->GetCertChain(server_address, client_address, hostname,
+ cert_matched_sni);
+}
+
+void FakeProofSource::ComputeTlsSignature(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ std::unique_ptr<ProofSource::SignatureCallback> callback) {
+ QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
+ if (!active_) {
+ QUIC_LOG(INFO) << "Not active - directly calling delegate";
+ delegate_->ComputeTlsSignature(server_address, client_address, hostname,
+ signature_algorithm, in,
+ std::move(callback));
+ return;
+ }
+
+ QUIC_LOG(INFO) << "Adding pending op";
+ pending_ops_.push_back(std::make_unique<ComputeSignatureOp>(
+ server_address, client_address, hostname, signature_algorithm, in,
+ std::move(callback), delegate_.get()));
+}
+
+absl::InlinedVector<uint16_t, 8>
+FakeProofSource::SupportedTlsSignatureAlgorithms() const {
+ return delegate_->SupportedTlsSignatureAlgorithms();
+}
+
+ProofSource::TicketCrypter* FakeProofSource::GetTicketCrypter() {
+ if (ticket_crypter_) {
+ return ticket_crypter_.get();
+ }
+ return delegate_->GetTicketCrypter();
+}
+
+void FakeProofSource::SetTicketCrypter(
+ std::unique_ptr<TicketCrypter> ticket_crypter) {
+ ticket_crypter_ = std::move(ticket_crypter);
+}
+
+int FakeProofSource::NumPendingCallbacks() const {
+ return pending_ops_.size();
+}
+
+void FakeProofSource::InvokePendingCallback(int n) {
+ QUICHE_CHECK(NumPendingCallbacks() > n);
+
+ pending_ops_[n]->Run();
+
+ auto it = pending_ops_.begin() + n;
+ pending_ops_.erase(it);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/fake_proof_source.h b/quiche/quic/test_tools/fake_proof_source.h
new file mode 100644
index 0000000..f2f5cc6
--- /dev/null
+++ b/quiche/quic/test_tools/fake_proof_source.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_H_
+#define QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/proof_source.h"
+
+namespace quic {
+namespace test {
+
+// Implementation of ProofSource which delegates to a ProofSourceForTesting, but
+// allows for overriding certain functionality. FakeProofSource allows
+// intercepting calls to GetProof and ComputeTlsSignature to force them to run
+// asynchronously, and allow the caller to see that the call is pending and
+// resume the operation at the caller's choosing. FakeProofSource also allows
+// the caller to replace the TicketCrypter provided by
+// FakeProofSource::GetTicketCrypter.
+class FakeProofSource : public ProofSource {
+ public:
+ FakeProofSource();
+ ~FakeProofSource() override;
+
+ // Before this object is "active", all calls to GetProof will be delegated
+ // immediately. Once "active", the async ones will be intercepted. This
+ // distinction is necessary to ensure that GetProof can be called without
+ // interference during test case setup.
+ void Activate();
+
+ // ProofSource interface
+ void GetProof(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ const std::string& server_config,
+ QuicTransportVersion transport_version,
+ absl::string_view chlo_hash,
+ std::unique_ptr<ProofSource::Callback> callback) override;
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ bool* cert_matched_sni) override;
+ void ComputeTlsSignature(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ std::unique_ptr<ProofSource::SignatureCallback> callback) override;
+ absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
+ const override;
+ TicketCrypter* GetTicketCrypter() override;
+
+ // Sets the TicketCrypter to use. If nullptr, the TicketCrypter from
+ // ProofSourceForTesting will be returned instead.
+ void SetTicketCrypter(std::unique_ptr<TicketCrypter> ticket_crypter);
+
+ // Get the number of callbacks which are pending
+ int NumPendingCallbacks() const;
+
+ // Invoke a pending callback. The index refers to the position in
+ // pending_ops_ of the callback to be completed.
+ void InvokePendingCallback(int n);
+
+ private:
+ std::unique_ptr<ProofSource> delegate_;
+ std::unique_ptr<TicketCrypter> ticket_crypter_;
+ bool active_ = false;
+
+ class PendingOp {
+ public:
+ virtual ~PendingOp();
+ virtual void Run() = 0;
+ };
+
+ class GetProofOp : public PendingOp {
+ public:
+ GetProofOp(const QuicSocketAddress& server_addr,
+ const QuicSocketAddress& client_address,
+ std::string hostname,
+ std::string server_config,
+ QuicTransportVersion transport_version,
+ std::string chlo_hash,
+ std::unique_ptr<ProofSource::Callback> callback,
+ ProofSource* delegate);
+ ~GetProofOp() override;
+
+ void Run() override;
+
+ private:
+ QuicSocketAddress server_address_;
+ QuicSocketAddress client_address_;
+ std::string hostname_;
+ std::string server_config_;
+ QuicTransportVersion transport_version_;
+ std::string chlo_hash_;
+ std::unique_ptr<ProofSource::Callback> callback_;
+ ProofSource* delegate_;
+ };
+
+ class ComputeSignatureOp : public PendingOp {
+ public:
+ ComputeSignatureOp(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ std::string hostname,
+ uint16_t sig_alg,
+ absl::string_view in,
+ std::unique_ptr<ProofSource::SignatureCallback> callback,
+ ProofSource* delegate);
+ ~ComputeSignatureOp() override;
+
+ void Run() override;
+
+ private:
+ QuicSocketAddress server_address_;
+ QuicSocketAddress client_address_;
+ std::string hostname_;
+ uint16_t sig_alg_;
+ std::string in_;
+ std::unique_ptr<ProofSource::SignatureCallback> callback_;
+ ProofSource* delegate_;
+ };
+
+ std::vector<std::unique_ptr<PendingOp>> pending_ops_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_H_
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.cc b/quiche/quic/test_tools/fake_proof_source_handle.cc
new file mode 100644
index 0000000..0736b99
--- /dev/null
+++ b/quiche/quic/test_tools/fake_proof_source_handle.cc
@@ -0,0 +1,241 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/fake_proof_source_handle.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+struct QUIC_EXPORT_PRIVATE ComputeSignatureResult {
+ bool ok;
+ std::string signature;
+ std::unique_ptr<ProofSource::Details> details;
+};
+
+class QUIC_EXPORT_PRIVATE ResultSavingSignatureCallback
+ : public ProofSource::SignatureCallback {
+ public:
+ explicit ResultSavingSignatureCallback(
+ absl::optional<ComputeSignatureResult>* result)
+ : result_(result) {
+ QUICHE_DCHECK(!result_->has_value());
+ }
+ void Run(bool ok,
+ std::string signature,
+ std::unique_ptr<ProofSource::Details> details) override {
+ result_->emplace(
+ ComputeSignatureResult{ok, std::move(signature), std::move(details)});
+ }
+
+ private:
+ absl::optional<ComputeSignatureResult>* result_;
+};
+
+ComputeSignatureResult ComputeSignatureNow(
+ ProofSource* delegate,
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in) {
+ absl::optional<ComputeSignatureResult> result;
+ delegate->ComputeTlsSignature(
+ server_address, client_address, hostname, signature_algorithm, in,
+ std::make_unique<ResultSavingSignatureCallback>(&result));
+ QUICHE_CHECK(result.has_value())
+ << "delegate->ComputeTlsSignature must computes a "
+ "signature immediately";
+ return std::move(result.value());
+}
+} // namespace
+
+FakeProofSourceHandle::FakeProofSourceHandle(
+ ProofSource* delegate, ProofSourceHandleCallback* callback,
+ Action select_cert_action, Action compute_signature_action,
+ QuicDelayedSSLConfig dealyed_ssl_config)
+ : delegate_(delegate),
+ callback_(callback),
+ select_cert_action_(select_cert_action),
+ compute_signature_action_(compute_signature_action),
+ dealyed_ssl_config_(dealyed_ssl_config) {}
+
+void FakeProofSourceHandle::CloseHandle() {
+ select_cert_op_.reset();
+ compute_signature_op_.reset();
+ closed_ = true;
+}
+
+QuicAsyncStatus FakeProofSourceHandle::SelectCertificate(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ absl::string_view ssl_capabilities,
+ const std::string& hostname,
+ absl::string_view client_hello,
+ const std::string& alpn,
+ absl::optional<std::string> alps,
+ const std::vector<uint8_t>& quic_transport_params,
+ const absl::optional<std::vector<uint8_t>>& early_data_context,
+ const QuicSSLConfig& ssl_config) {
+ if (select_cert_action_ != Action::FAIL_SYNC_DO_NOT_CHECK_CLOSED) {
+ QUICHE_CHECK(!closed_);
+ }
+ all_select_cert_args_.push_back(SelectCertArgs(
+ server_address, client_address, ssl_capabilities, hostname, client_hello,
+ alpn, alps, quic_transport_params, early_data_context, ssl_config));
+
+ if (select_cert_action_ == Action::DELEGATE_ASYNC ||
+ select_cert_action_ == Action::FAIL_ASYNC) {
+ select_cert_op_.emplace(delegate_, callback_, select_cert_action_,
+ all_select_cert_args_.back(), dealyed_ssl_config_);
+ return QUIC_PENDING;
+ } else if (select_cert_action_ == Action::FAIL_SYNC ||
+ select_cert_action_ == Action::FAIL_SYNC_DO_NOT_CHECK_CLOSED) {
+ callback()->OnSelectCertificateDone(
+ /*ok=*/false,
+ /*is_sync=*/true, nullptr, /*handshake_hints=*/absl::string_view(),
+ /*ticket_encryption_key=*/absl::string_view(),
+ /*cert_matched_sni=*/false, dealyed_ssl_config_);
+ return QUIC_FAILURE;
+ }
+
+ QUICHE_DCHECK(select_cert_action_ == Action::DELEGATE_SYNC);
+ bool cert_matched_sni;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
+ delegate_->GetCertChain(server_address, client_address, hostname,
+ &cert_matched_sni);
+
+ bool ok = chain && !chain->certs.empty();
+ callback_->OnSelectCertificateDone(
+ ok, /*is_sync=*/true, chain.get(),
+ /*handshake_hints=*/absl::string_view(),
+ /*ticket_encryption_key=*/absl::string_view(),
+ /*cert_matched_sni=*/cert_matched_sni, dealyed_ssl_config_);
+ return ok ? QUIC_SUCCESS : QUIC_FAILURE;
+}
+
+QuicAsyncStatus FakeProofSourceHandle::ComputeSignature(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ size_t max_signature_size) {
+ if (compute_signature_action_ != Action::FAIL_SYNC_DO_NOT_CHECK_CLOSED) {
+ QUICHE_CHECK(!closed_);
+ }
+ all_compute_signature_args_.push_back(
+ ComputeSignatureArgs(server_address, client_address, hostname,
+ signature_algorithm, in, max_signature_size));
+
+ if (compute_signature_action_ == Action::DELEGATE_ASYNC ||
+ compute_signature_action_ == Action::FAIL_ASYNC) {
+ compute_signature_op_.emplace(delegate_, callback_,
+ compute_signature_action_,
+ all_compute_signature_args_.back());
+ return QUIC_PENDING;
+ } else if (compute_signature_action_ == Action::FAIL_SYNC ||
+ compute_signature_action_ ==
+ Action::FAIL_SYNC_DO_NOT_CHECK_CLOSED) {
+ callback()->OnComputeSignatureDone(/*ok=*/false, /*is_sync=*/true,
+ /*signature=*/"", /*details=*/nullptr);
+ return QUIC_FAILURE;
+ }
+
+ QUICHE_DCHECK(compute_signature_action_ == Action::DELEGATE_SYNC);
+ ComputeSignatureResult result =
+ ComputeSignatureNow(delegate_, server_address, client_address, hostname,
+ signature_algorithm, in);
+ callback_->OnComputeSignatureDone(
+ result.ok, /*is_sync=*/true, result.signature, std::move(result.details));
+ return result.ok ? QUIC_SUCCESS : QUIC_FAILURE;
+}
+
+ProofSourceHandleCallback* FakeProofSourceHandle::callback() {
+ return callback_;
+}
+
+bool FakeProofSourceHandle::HasPendingOperation() const {
+ int num_pending_operations = NumPendingOperations();
+ return num_pending_operations > 0;
+}
+
+void FakeProofSourceHandle::CompletePendingOperation() {
+ QUICHE_DCHECK_LE(NumPendingOperations(), 1);
+
+ if (select_cert_op_.has_value()) {
+ select_cert_op_->Run();
+ select_cert_op_.reset();
+ } else if (compute_signature_op_.has_value()) {
+ compute_signature_op_->Run();
+ compute_signature_op_.reset();
+ }
+}
+
+int FakeProofSourceHandle::NumPendingOperations() const {
+ return static_cast<int>(select_cert_op_.has_value()) +
+ static_cast<int>(compute_signature_op_.has_value());
+}
+
+FakeProofSourceHandle::SelectCertOperation::SelectCertOperation(
+ ProofSource* delegate, ProofSourceHandleCallback* callback, Action action,
+ SelectCertArgs args, QuicDelayedSSLConfig dealyed_ssl_config)
+ : PendingOperation(delegate, callback, action),
+ args_(std::move(args)),
+ dealyed_ssl_config_(dealyed_ssl_config) {}
+
+void FakeProofSourceHandle::SelectCertOperation::Run() {
+ if (action_ == Action::FAIL_ASYNC) {
+ callback_->OnSelectCertificateDone(
+ /*ok=*/false,
+ /*is_sync=*/false, nullptr,
+ /*handshake_hints=*/absl::string_view(),
+ /*ticket_encryption_key=*/absl::string_view(),
+ /*cert_matched_sni=*/false, dealyed_ssl_config_);
+ } else if (action_ == Action::DELEGATE_ASYNC) {
+ bool cert_matched_sni;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
+ delegate_->GetCertChain(args_.server_address, args_.client_address,
+ args_.hostname, &cert_matched_sni);
+ bool ok = chain && !chain->certs.empty();
+ callback_->OnSelectCertificateDone(
+ ok, /*is_sync=*/false, chain.get(),
+ /*handshake_hints=*/absl::string_view(),
+ /*ticket_encryption_key=*/absl::string_view(),
+ /*cert_matched_sni=*/cert_matched_sni, dealyed_ssl_config_);
+ } else {
+ QUIC_BUG(quic_bug_10139_1)
+ << "Unexpected action: " << static_cast<int>(action_);
+ }
+}
+
+FakeProofSourceHandle::ComputeSignatureOperation::ComputeSignatureOperation(
+ ProofSource* delegate,
+ ProofSourceHandleCallback* callback,
+ Action action,
+ ComputeSignatureArgs args)
+ : PendingOperation(delegate, callback, action), args_(std::move(args)) {}
+
+void FakeProofSourceHandle::ComputeSignatureOperation::Run() {
+ if (action_ == Action::FAIL_ASYNC) {
+ callback_->OnComputeSignatureDone(
+ /*ok=*/false, /*is_sync=*/false,
+ /*signature=*/"", /*details=*/nullptr);
+ } else if (action_ == Action::DELEGATE_ASYNC) {
+ ComputeSignatureResult result = ComputeSignatureNow(
+ delegate_, args_.server_address, args_.client_address, args_.hostname,
+ args_.signature_algorithm, args_.in);
+ callback_->OnComputeSignatureDone(result.ok, /*is_sync=*/false,
+ result.signature,
+ std::move(result.details));
+ } else {
+ QUIC_BUG(quic_bug_10139_2)
+ << "Unexpected action: " << static_cast<int>(action_);
+ }
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.h b/quiche/quic/test_tools/fake_proof_source_handle.h
new file mode 100644
index 0000000..ac0d184
--- /dev/null
+++ b/quiche/quic/test_tools/fake_proof_source_handle.h
@@ -0,0 +1,201 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_HANDLE_H_
+#define QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_HANDLE_H_
+
+#include "quiche/quic/core/crypto/proof_source.h"
+
+namespace quic {
+namespace test {
+
+// FakeProofSourceHandle allows its behavior to be scripted for testing.
+class FakeProofSourceHandle : public ProofSourceHandle {
+ public:
+ // What would an operation return when it is called.
+ enum class Action {
+ // Delegate the operation to |delegate_| immediately.
+ DELEGATE_SYNC = 0,
+ // Handle the operation asynchronously. Delegate the operation to
+ // |delegate_| when the caller calls CompletePendingOperation().
+ DELEGATE_ASYNC,
+ // Fail the operation immediately.
+ FAIL_SYNC,
+ // Handle the operation asynchronously. Fail the operation when the caller
+ // calls CompletePendingOperation().
+ FAIL_ASYNC,
+ // Similar to FAIL_SYNC, but do not QUICHE_CHECK(!closed_) when invoked.
+ FAIL_SYNC_DO_NOT_CHECK_CLOSED,
+ };
+
+ // |delegate| must do cert selection and signature synchronously.
+ // |dealyed_ssl_config| is the config passed to OnSelectCertificateDone.
+ FakeProofSourceHandle(
+ ProofSource* delegate, ProofSourceHandleCallback* callback,
+ Action select_cert_action, Action compute_signature_action,
+ QuicDelayedSSLConfig dealyed_ssl_config = QuicDelayedSSLConfig());
+
+ ~FakeProofSourceHandle() override = default;
+
+ void CloseHandle() override;
+
+ QuicAsyncStatus SelectCertificate(
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ absl::string_view ssl_capabilities,
+ const std::string& hostname,
+ absl::string_view client_hello,
+ const std::string& alpn,
+ absl::optional<std::string> alps,
+ const std::vector<uint8_t>& quic_transport_params,
+ const absl::optional<std::vector<uint8_t>>& early_data_context,
+ const QuicSSLConfig& ssl_config) override;
+
+ QuicAsyncStatus ComputeSignature(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ size_t max_signature_size) override;
+
+ ProofSourceHandleCallback* callback() override;
+
+ // Whether there's a pending operation in |this|.
+ bool HasPendingOperation() const;
+ void CompletePendingOperation();
+
+ struct SelectCertArgs {
+ SelectCertArgs(QuicSocketAddress server_address,
+ QuicSocketAddress client_address,
+ absl::string_view ssl_capabilities,
+ std::string hostname,
+ absl::string_view client_hello,
+ std::string alpn,
+ absl::optional<std::string> alps,
+ std::vector<uint8_t> quic_transport_params,
+ absl::optional<std::vector<uint8_t>> early_data_context,
+ QuicSSLConfig ssl_config)
+ : server_address(server_address),
+ client_address(client_address),
+ ssl_capabilities(ssl_capabilities),
+ hostname(hostname),
+ client_hello(client_hello),
+ alpn(alpn),
+ alps(alps),
+ quic_transport_params(quic_transport_params),
+ early_data_context(early_data_context),
+ ssl_config(ssl_config) {}
+
+ QuicSocketAddress server_address;
+ QuicSocketAddress client_address;
+ std::string ssl_capabilities;
+ std::string hostname;
+ std::string client_hello;
+ std::string alpn;
+ absl::optional<std::string> alps;
+ std::vector<uint8_t> quic_transport_params;
+ absl::optional<std::vector<uint8_t>> early_data_context;
+ QuicSSLConfig ssl_config;
+ };
+
+ struct ComputeSignatureArgs {
+ ComputeSignatureArgs(QuicSocketAddress server_address,
+ QuicSocketAddress client_address,
+ std::string hostname,
+ uint16_t signature_algorithm,
+ absl::string_view in,
+ size_t max_signature_size)
+ : server_address(server_address),
+ client_address(client_address),
+ hostname(hostname),
+ signature_algorithm(signature_algorithm),
+ in(in),
+ max_signature_size(max_signature_size) {}
+
+ QuicSocketAddress server_address;
+ QuicSocketAddress client_address;
+ std::string hostname;
+ uint16_t signature_algorithm;
+ std::string in;
+ size_t max_signature_size;
+ };
+
+ std::vector<SelectCertArgs> all_select_cert_args() const {
+ return all_select_cert_args_;
+ }
+
+ std::vector<ComputeSignatureArgs> all_compute_signature_args() const {
+ return all_compute_signature_args_;
+ }
+
+ private:
+ class PendingOperation {
+ public:
+ PendingOperation(ProofSource* delegate,
+ ProofSourceHandleCallback* callback,
+ Action action)
+ : delegate_(delegate), callback_(callback), action_(action) {}
+ virtual ~PendingOperation() = default;
+ virtual void Run() = 0;
+
+ protected:
+ ProofSource* delegate_;
+ ProofSourceHandleCallback* callback_;
+ Action action_;
+ };
+
+ class SelectCertOperation : public PendingOperation {
+ public:
+ SelectCertOperation(ProofSource* delegate,
+ ProofSourceHandleCallback* callback, Action action,
+ SelectCertArgs args,
+ QuicDelayedSSLConfig dealyed_ssl_config);
+
+ ~SelectCertOperation() override = default;
+
+ void Run() override;
+
+ private:
+ const SelectCertArgs args_;
+ const QuicDelayedSSLConfig dealyed_ssl_config_;
+ };
+
+ class ComputeSignatureOperation : public PendingOperation {
+ public:
+ ComputeSignatureOperation(ProofSource* delegate,
+ ProofSourceHandleCallback* callback,
+ Action action,
+ ComputeSignatureArgs args);
+
+ ~ComputeSignatureOperation() override = default;
+
+ void Run() override;
+
+ private:
+ const ComputeSignatureArgs args_;
+ };
+
+ private:
+ int NumPendingOperations() const;
+
+ bool closed_ = false;
+ ProofSource* delegate_;
+ ProofSourceHandleCallback* callback_;
+ // Action for the next select cert operation.
+ Action select_cert_action_ = Action::DELEGATE_SYNC;
+ // Action for the next compute signature operation.
+ Action compute_signature_action_ = Action::DELEGATE_SYNC;
+ const QuicDelayedSSLConfig dealyed_ssl_config_;
+ absl::optional<SelectCertOperation> select_cert_op_;
+ absl::optional<ComputeSignatureOperation> compute_signature_op_;
+
+ // Save all the select cert and compute signature args for tests to inspect.
+ std::vector<SelectCertArgs> all_select_cert_args_;
+ std::vector<ComputeSignatureArgs> all_compute_signature_args_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_HANDLE_H_
diff --git a/quiche/quic/test_tools/first_flight.cc b/quiche/quic/test_tools/first_flight.cc
new file mode 100644
index 0000000..2f70943
--- /dev/null
+++ b/quiche/quic/test_tools/first_flight.cc
@@ -0,0 +1,163 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/first_flight.h"
+
+#include <memory>
+#include <vector>
+
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+#include "quiche/quic/core/http/quic_client_push_promise_index.h"
+#include "quiche/quic/core/http/quic_spdy_client_session.h"
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_versions.h"
+#include "quiche/quic/platform/api/quic_ip_address.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+// Utility class that creates a custom HTTP/3 session and QUIC connection in
+// order to extract the first flight of packets it sends. This is meant to only
+// be used by GetFirstFlightOfPackets() below.
+class FirstFlightExtractor : public DelegatedPacketWriter::Delegate {
+ public:
+ FirstFlightExtractor(const ParsedQuicVersion& version,
+ const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id,
+ std::unique_ptr<QuicCryptoClientConfig> crypto_config)
+ : version_(version),
+ server_connection_id_(server_connection_id),
+ client_connection_id_(client_connection_id),
+ writer_(this),
+ config_(config),
+ crypto_config_(std::move(crypto_config)) {
+ EXPECT_NE(version_, UnsupportedQuicVersion());
+ }
+
+ FirstFlightExtractor(const ParsedQuicVersion& version,
+ const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id)
+ : FirstFlightExtractor(
+ version, config, server_connection_id, client_connection_id,
+ std::make_unique<QuicCryptoClientConfig>(
+ crypto_test_utils::ProofVerifierForTesting())) {}
+
+ void GenerateFirstFlight() {
+ crypto_config_->set_alpn(AlpnForVersion(version_));
+ connection_ =
+ new QuicConnection(server_connection_id_,
+ /*initial_self_address=*/QuicSocketAddress(),
+ QuicSocketAddress(TestPeerIPAddress(), kTestPort),
+ &connection_helper_, &alarm_factory_, &writer_,
+ /*owns_writer=*/false, Perspective::IS_CLIENT,
+ ParsedQuicVersionVector{version_});
+ connection_->set_client_connection_id(client_connection_id_);
+ session_ = std::make_unique<QuicSpdyClientSession>(
+ config_, ParsedQuicVersionVector{version_},
+ connection_, // session_ takes ownership of connection_ here.
+ TestServerId(), crypto_config_.get(), &push_promise_index_);
+ session_->Initialize();
+ session_->CryptoConnect();
+ }
+
+ void OnDelegatedPacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& /*self_client_address*/,
+ const QuicSocketAddress& /*peer_client_address*/,
+ PerPacketOptions* /*options*/) override {
+ packets_.emplace_back(
+ QuicReceivedPacket(buffer, buf_len,
+ connection_helper_.GetClock()->ApproximateNow(),
+ /*owns_buffer=*/false)
+ .Clone());
+ }
+
+ std::vector<std::unique_ptr<QuicReceivedPacket>>&& ConsumePackets() {
+ return std::move(packets_);
+ }
+
+ private:
+ ParsedQuicVersion version_;
+ QuicConnectionId server_connection_id_;
+ QuicConnectionId client_connection_id_;
+ MockQuicConnectionHelper connection_helper_;
+ MockAlarmFactory alarm_factory_;
+ DelegatedPacketWriter writer_;
+ QuicConfig config_;
+ std::unique_ptr<QuicCryptoClientConfig> crypto_config_;
+ QuicClientPushPromiseIndex push_promise_index_;
+ QuicConnection* connection_; // Owned by session_.
+ std::unique_ptr<QuicSpdyClientSession> session_;
+ std::vector<std::unique_ptr<QuicReceivedPacket>> packets_;
+};
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version, const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id,
+ std::unique_ptr<QuicCryptoClientConfig> crypto_config) {
+ FirstFlightExtractor first_flight_extractor(
+ version, config, server_connection_id, client_connection_id,
+ std::move(crypto_config));
+ first_flight_extractor.GenerateFirstFlight();
+ return first_flight_extractor.ConsumePackets();
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id) {
+ FirstFlightExtractor first_flight_extractor(
+ version, config, server_connection_id, client_connection_id);
+ first_flight_extractor.GenerateFirstFlight();
+ return first_flight_extractor.ConsumePackets();
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConfig& config,
+ const QuicConnectionId& server_connection_id) {
+ return GetFirstFlightOfPackets(version, config, server_connection_id,
+ EmptyQuicConnectionId());
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConfig& config) {
+ return GetFirstFlightOfPackets(version, config, TestConnectionId());
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id) {
+ return GetFirstFlightOfPackets(version, DefaultQuicConfig(),
+ server_connection_id, client_connection_id);
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id) {
+ return GetFirstFlightOfPackets(version, DefaultQuicConfig(),
+ server_connection_id, EmptyQuicConnectionId());
+}
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version) {
+ return GetFirstFlightOfPackets(version, DefaultQuicConfig(),
+ TestConnectionId());
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/first_flight.h b/quiche/quic/test_tools/first_flight.h
new file mode 100644
index 0000000..b6118ba
--- /dev/null
+++ b/quiche/quic/test_tools/first_flight.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_FIRST_FLIGHT_H_
+#define QUICHE_QUIC_TEST_TOOLS_FIRST_FLIGHT_H_
+
+#include <memory>
+#include <vector>
+
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_versions.h"
+#include "quiche/quic/platform/api/quic_ip_address.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+
+namespace quic {
+namespace test {
+
+// Implementation of QuicPacketWriter that sends all packets to a delegate.
+class QUIC_NO_EXPORT DelegatedPacketWriter : public QuicPacketWriter {
+ public:
+ class QUIC_NO_EXPORT Delegate {
+ public:
+ virtual ~Delegate() {}
+ // Note that |buffer| may be released after this call completes so overrides
+ // that want to use the data after the call is complete MUST copy it.
+ virtual void OnDelegatedPacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_client_address,
+ const QuicSocketAddress& peer_client_address,
+ PerPacketOptions* options) = 0;
+ };
+
+ // |delegate| MUST be valid for the duration of the DelegatedPacketWriter's
+ // lifetime.
+ explicit DelegatedPacketWriter(Delegate* delegate) : delegate_(delegate) {
+ QUICHE_CHECK_NE(delegate_, nullptr);
+ }
+
+ // Overrides for QuicPacketWriter.
+ bool IsWriteBlocked() const override { return false; }
+ void SetWritable() override {}
+ absl::optional<int> MessageTooBigErrorCode() const override {
+ return absl::nullopt;
+ }
+ QuicByteCount GetMaxPacketSize(
+ const QuicSocketAddress& /*peer_address*/) const override {
+ return kMaxOutgoingPacketSize;
+ }
+ bool SupportsReleaseTime() const override { return false; }
+ bool IsBatchMode() const override { return false; }
+ QuicPacketBuffer GetNextWriteLocation(
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/) override {
+ return {nullptr, nullptr};
+ }
+ WriteResult Flush() override { return WriteResult(WRITE_STATUS_OK, 0); }
+
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_client_address,
+ const QuicSocketAddress& peer_client_address,
+ PerPacketOptions* options) override {
+ delegate_->OnDelegatedPacket(buffer, buf_len, self_client_address,
+ peer_client_address, options);
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ }
+
+ private:
+ Delegate* delegate_; // Unowned.
+};
+
+// Returns an array of packets that represent the first flight of a real
+// HTTP/3 connection. In most cases, this array will only contain one packet
+// that carries the CHLO.
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version, const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id,
+ std::unique_ptr<QuicCryptoClientConfig> crypto_config);
+
+// Below are various convenience overloads that use default values for the
+// omitted parameters:
+// |config| = DefaultQuicConfig(),
+// |server_connection_id| = TestConnectionId(),
+// |client_connection_id| = EmptyQuicConnectionId().
+// |crypto_config| =
+// QuicCryptoClientConfig(crypto_test_utils::ProofVerifierForTesting())
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version, const QuicConfig& config,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id);
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConfig& config,
+ const QuicConnectionId& server_connection_id);
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& client_connection_id);
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id);
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version,
+ const QuicConfig& config);
+
+std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
+ const ParsedQuicVersion& version);
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_FIRST_FLIGHT_H_
diff --git a/quiche/quic/test_tools/fuzzing/README.md b/quiche/quic/test_tools/fuzzing/README.md
new file mode 100644
index 0000000..d914fb9
--- /dev/null
+++ b/quiche/quic/test_tools/fuzzing/README.md
@@ -0,0 +1,22 @@
+This directory contains several fuzz tests for QUIC code:
+
+- quic_framer_fuzzer: A test for CryptoFramer::ParseMessage and
+ QuicFramer::ProcessPacket using random packet data.
+- quic_framer_process_data_packet_fuzzer: A test for QuicFramer::ProcessPacket
+ where the packet has a valid public header, is decryptable, and contains
+ random QUIC payload.
+
+To build and run the fuzz tests, using quic_framer_fuzzer as an example:
+
+```sh
+$ blaze build --config=asan-fuzzer //gfe/quic/test_tools/fuzzing/...
+$ CORPUS_DIR=`mktemp -d` && echo ${CORPUS_DIR}
+$ ./blaze-bin/gfe/quic/test_tools/fuzzing/quic_framer_fuzzer ${CORPUS_DIR} -use_counters=0
+```
+
+By default this fuzzes with 64 byte chunks, to test the framer with more
+realistic size input, try 1350 (max payload size of a QUIC packet):
+
+```sh
+$ ./blaze-bin/gfe/quic/test_tools/fuzzing/quic_framer_fuzzer ${CORPUS_DIR} -use_counters=0 -max_len=1350
+```
diff --git a/quiche/quic/test_tools/fuzzing/quic_framer_fuzzer.cc b/quiche/quic/test_tools/fuzzing/quic_framer_fuzzer.cc
new file mode 100644
index 0000000..7b1e09f
--- /dev/null
+++ b/quiche/quic/test_tools/fuzzing/quic_framer_fuzzer.cc
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/crypto_framer.h"
+#include "quiche/quic/core/crypto/crypto_handshake_message.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ quic::QuicFramer framer(quic::AllSupportedVersions(), quic::QuicTime::Zero(),
+ quic::Perspective::IS_SERVER,
+ quic::kQuicDefaultConnectionIdLength);
+ const char* const packet_bytes = reinterpret_cast<const char*>(data);
+
+ // Test the CryptoFramer.
+ absl::string_view crypto_input(packet_bytes, size);
+ std::unique_ptr<quic::CryptoHandshakeMessage> handshake_message(
+ quic::CryptoFramer::ParseMessage(crypto_input));
+
+ // Test the regular QuicFramer with the same input.
+ quic::test::NoOpFramerVisitor visitor;
+ framer.set_visitor(&visitor);
+ quic::QuicEncryptedPacket packet(packet_bytes, size);
+ framer.ProcessPacket(packet);
+
+ return 0;
+}
diff --git a/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
new file mode 100644
index 0000000..c97b6e8
--- /dev/null
+++ b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
@@ -0,0 +1,285 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <fuzzer/FuzzedDataProvider.h>
+#include <algorithm>
+#include <cstdint>
+#include <string>
+
+#include "absl/base/macros.h"
+#include "quiche/quic/core/crypto/null_decrypter.h"
+#include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_constants.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/core/quic_versions.h"
+#include "quiche/quic/test_tools/quic_framer_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+using quic::DiversificationNonce;
+using quic::EncryptionLevel;
+using quic::FirstSendingPacketNumber;
+using quic::GetPacketHeaderSize;
+using quic::kEthernetMTU;
+using quic::kQuicDefaultConnectionIdLength;
+using quic::NullDecrypter;
+using quic::NullEncrypter;
+using quic::PacketHeaderFormat;
+using quic::ParsedQuicVersion;
+using quic::ParsedQuicVersionVector;
+using quic::Perspective;
+using quic::QuicConnectionId;
+using quic::QuicDataReader;
+using quic::QuicDataWriter;
+using quic::QuicEncryptedPacket;
+using quic::QuicFramer;
+using quic::QuicFramerVisitorInterface;
+using quic::QuicLongHeaderType;
+using quic::QuicPacketHeader;
+using quic::QuicPacketNumber;
+using quic::QuicTime;
+using quic::QuicTransportVersion;
+using quic::test::NoOpFramerVisitor;
+using quic::test::QuicFramerPeer;
+
+PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider,
+ ParsedQuicVersion version) {
+ if (!version.HasIetfInvariantHeader()) {
+ return quic::GOOGLE_QUIC_PACKET;
+ }
+ return provider->ConsumeBool() ? quic::IETF_QUIC_LONG_HEADER_PACKET
+ : quic::IETF_QUIC_SHORT_HEADER_PACKET;
+}
+
+ParsedQuicVersion ConsumeParsedQuicVersion(FuzzedDataProvider* provider) {
+ // TODO(wub): Add support for v49+.
+ const QuicTransportVersion transport_versions[] = {
+ quic::QUIC_VERSION_43,
+ quic::QUIC_VERSION_46,
+ };
+
+ return ParsedQuicVersion(
+ quic::PROTOCOL_QUIC_CRYPTO,
+ transport_versions[provider->ConsumeIntegralInRange<uint8_t>(
+ 0, ABSL_ARRAYSIZE(transport_versions) - 1)]);
+}
+
+// QuicSelfContainedPacketHeader is a QuicPacketHeader with built-in stroage for
+// diversification nonce.
+struct QuicSelfContainedPacketHeader : public QuicPacketHeader {
+ DiversificationNonce nonce_storage;
+};
+
+// Construct a random data packet header that 1) can be successfully serialized
+// at sender, and 2) the serialzied buffer can pass the receiver framer's
+// ProcessPublicHeader and DecryptPayload functions.
+QuicSelfContainedPacketHeader ConsumeQuicPacketHeader(
+ FuzzedDataProvider* provider,
+ Perspective receiver_perspective) {
+ QuicSelfContainedPacketHeader header;
+
+ header.version = ConsumeParsedQuicVersion(provider);
+
+ header.form = ConsumePacketHeaderFormat(provider, header.version);
+
+ const std::string cid_bytes =
+ provider->ConsumeBytesAsString(kQuicDefaultConnectionIdLength);
+ if (receiver_perspective == Perspective::IS_SERVER) {
+ header.destination_connection_id =
+ QuicConnectionId(cid_bytes.c_str(), cid_bytes.size());
+ header.destination_connection_id_included = quic::CONNECTION_ID_PRESENT;
+ header.source_connection_id_included = quic::CONNECTION_ID_ABSENT;
+ } else {
+ header.source_connection_id =
+ QuicConnectionId(cid_bytes.c_str(), cid_bytes.size());
+ header.source_connection_id_included = quic::CONNECTION_ID_PRESENT;
+ header.destination_connection_id_included = quic::CONNECTION_ID_ABSENT;
+ }
+
+ header.version_flag = receiver_perspective == Perspective::IS_SERVER;
+ header.reset_flag = false;
+
+ header.packet_number =
+ QuicPacketNumber(provider->ConsumeIntegral<uint32_t>());
+ if (header.packet_number < FirstSendingPacketNumber()) {
+ header.packet_number = FirstSendingPacketNumber();
+ }
+ header.packet_number_length = quic::PACKET_4BYTE_PACKET_NUMBER;
+
+ header.remaining_packet_length = 0;
+
+ if (header.form != quic::GOOGLE_QUIC_PACKET && header.version_flag) {
+ header.long_packet_type = static_cast<QuicLongHeaderType>(
+ provider->ConsumeIntegralInRange<uint8_t>(
+ // INITIAL, ZERO_RTT_PROTECTED, or HANDSHAKE.
+ static_cast<uint8_t>(quic::INITIAL),
+ static_cast<uint8_t>(quic::HANDSHAKE)));
+ } else {
+ header.long_packet_type = quic::INVALID_PACKET_TYPE;
+ }
+
+ if (header.form == quic::IETF_QUIC_LONG_HEADER_PACKET &&
+ header.long_packet_type == quic::ZERO_RTT_PROTECTED &&
+ receiver_perspective == Perspective::IS_CLIENT &&
+ header.version.handshake_protocol == quic::PROTOCOL_QUIC_CRYPTO) {
+ for (size_t i = 0; i < header.nonce_storage.size(); ++i) {
+ header.nonce_storage[i] = provider->ConsumeIntegral<char>();
+ }
+ header.nonce = &header.nonce_storage;
+ } else {
+ header.nonce = nullptr;
+ }
+
+ return header;
+}
+
+void SetupFramer(QuicFramer* framer, QuicFramerVisitorInterface* visitor) {
+ framer->set_visitor(visitor);
+ for (EncryptionLevel level :
+ {quic::ENCRYPTION_INITIAL, quic::ENCRYPTION_HANDSHAKE,
+ quic::ENCRYPTION_ZERO_RTT, quic::ENCRYPTION_FORWARD_SECURE}) {
+ framer->SetEncrypter(
+ level, std::make_unique<NullEncrypter>(framer->perspective()));
+ if (framer->version().KnowsWhichDecrypterToUse()) {
+ framer->InstallDecrypter(
+ level, std::make_unique<NullDecrypter>(framer->perspective()));
+ }
+ }
+
+ if (!framer->version().KnowsWhichDecrypterToUse()) {
+ framer->SetDecrypter(
+ quic::ENCRYPTION_INITIAL,
+ std::make_unique<NullDecrypter>(framer->perspective()));
+ }
+}
+
+class FuzzingFramerVisitor : public NoOpFramerVisitor {
+ public:
+ // Called after a successful ProcessPublicHeader.
+ bool OnUnauthenticatedPublicHeader(
+ const QuicPacketHeader& /*header*/) override {
+ ++process_public_header_success_count_;
+ return true;
+ }
+
+ // Called after a successful DecryptPayload.
+ bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
+ ++decrypted_packet_count_;
+ return true;
+ }
+
+ uint64_t process_public_header_success_count_ = 0;
+ uint64_t decrypted_packet_count_ = 0;
+};
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ FuzzedDataProvider data_provider(data, size);
+
+ const QuicTime creation_time =
+ QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(
+ data_provider.ConsumeIntegral<int32_t>());
+ Perspective receiver_perspective = data_provider.ConsumeBool()
+ ? Perspective::IS_CLIENT
+ : Perspective::IS_SERVER;
+ Perspective sender_perspective =
+ (receiver_perspective == Perspective::IS_CLIENT) ? Perspective::IS_SERVER
+ : Perspective::IS_CLIENT;
+
+ QuicSelfContainedPacketHeader header =
+ ConsumeQuicPacketHeader(&data_provider, receiver_perspective);
+
+ NoOpFramerVisitor sender_framer_visitor;
+ ParsedQuicVersionVector framer_versions = {header.version};
+ QuicFramer sender_framer(framer_versions, creation_time, sender_perspective,
+ kQuicDefaultConnectionIdLength);
+ SetupFramer(&sender_framer, &sender_framer_visitor);
+
+ FuzzingFramerVisitor receiver_framer_visitor;
+ QuicFramer receiver_framer(framer_versions, creation_time,
+ receiver_perspective,
+ kQuicDefaultConnectionIdLength);
+ SetupFramer(&receiver_framer, &receiver_framer_visitor);
+ if (receiver_perspective == Perspective::IS_CLIENT) {
+ QuicFramerPeer::SetLastSerializedServerConnectionId(
+ &receiver_framer, header.source_connection_id);
+ } else {
+ QuicFramerPeer::SetLastSerializedClientConnectionId(
+ &receiver_framer, header.source_connection_id);
+ }
+
+ std::array<char, kEthernetMTU> packet_buffer;
+ while (data_provider.remaining_bytes() > 16) {
+ const size_t last_remaining_bytes = data_provider.remaining_bytes();
+
+ // Get a randomized packet size.
+ uint16_t max_payload_size = static_cast<uint16_t>(
+ std::min<size_t>(data_provider.remaining_bytes(), 1350u));
+ uint16_t min_payload_size = std::min<uint16_t>(16u, max_payload_size);
+ uint16_t payload_size = data_provider.ConsumeIntegralInRange<uint16_t>(
+ min_payload_size, max_payload_size);
+
+ QUICHE_CHECK_NE(last_remaining_bytes, data_provider.remaining_bytes())
+ << "Check fail to avoid an infinite loop. ConsumeIntegralInRange("
+ << min_payload_size << ", " << max_payload_size
+ << ") did not consume any bytes. remaining_bytes:"
+ << last_remaining_bytes;
+
+ std::vector<char> payload_buffer =
+ data_provider.ConsumeBytes<char>(payload_size);
+ QUICHE_CHECK_GE(
+ packet_buffer.size(),
+ GetPacketHeaderSize(sender_framer.transport_version(), header) +
+ payload_buffer.size());
+
+ // Serialize the null-encrypted packet into |packet_buffer|.
+ QuicDataWriter writer(packet_buffer.size(), packet_buffer.data());
+ size_t length_field_offset = 0;
+ QUICHE_CHECK(sender_framer.AppendPacketHeader(header, &writer,
+ &length_field_offset));
+
+ QUICHE_CHECK(
+ writer.WriteBytes(payload_buffer.data(), payload_buffer.size()));
+
+ EncryptionLevel encryption_level =
+ quic::test::HeaderToEncryptionLevel(header);
+ QUICHE_CHECK(sender_framer.WriteIetfLongHeaderLength(
+ header, &writer, length_field_offset, encryption_level));
+
+ size_t encrypted_length = sender_framer.EncryptInPlace(
+ encryption_level, header.packet_number,
+ GetStartOfEncryptedData(sender_framer.transport_version(), header),
+ writer.length(), packet_buffer.size(), packet_buffer.data());
+ QUICHE_CHECK_NE(encrypted_length, 0u);
+
+ // Use receiver's framer to process the packet. Ensure both
+ // ProcessPublicHeader and DecryptPayload were called and succeeded.
+ QuicEncryptedPacket packet(packet_buffer.data(), encrypted_length);
+ QuicDataReader reader(packet.data(), packet.length());
+
+ const uint64_t process_public_header_success_count =
+ receiver_framer_visitor.process_public_header_success_count_;
+ const uint64_t decrypted_packet_count =
+ receiver_framer_visitor.decrypted_packet_count_;
+
+ receiver_framer.ProcessPacket(packet);
+
+ QUICHE_DCHECK_EQ(
+ process_public_header_success_count + 1,
+ receiver_framer_visitor.process_public_header_success_count_)
+ << "ProcessPublicHeader failed. error:"
+ << QuicErrorCodeToString(receiver_framer.error())
+ << ", error_detail:" << receiver_framer.detailed_error()
+ << ". header:" << header;
+ QUICHE_DCHECK_EQ(decrypted_packet_count + 1,
+ receiver_framer_visitor.decrypted_packet_count_)
+ << "Packet was not decrypted. error:"
+ << QuicErrorCodeToString(receiver_framer.error())
+ << ", error_detail:" << receiver_framer.detailed_error()
+ << ". header:" << header;
+ }
+ return 0;
+}
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.cc b/quiche/quic/test_tools/limited_mtu_test_writer.cc
new file mode 100644
index 0000000..ff009ee
--- /dev/null
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.cc
@@ -0,0 +1,30 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/limited_mtu_test_writer.h"
+
+namespace quic {
+namespace test {
+
+LimitedMtuTestWriter::LimitedMtuTestWriter(QuicByteCount mtu) : mtu_(mtu) {}
+
+LimitedMtuTestWriter::~LimitedMtuTestWriter() = default;
+
+WriteResult LimitedMtuTestWriter::WritePacket(
+ const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) {
+ if (buf_len > mtu_) {
+ // Drop the packet.
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ }
+
+ return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
+ peer_address, options);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.h b/quiche/quic/test_tools/limited_mtu_test_writer.h
new file mode 100644
index 0000000..f3fdc05
--- /dev/null
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_LIMITED_MTU_TEST_WRITER_H_
+#define QUICHE_QUIC_TEST_TOOLS_LIMITED_MTU_TEST_WRITER_H_
+
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+namespace test {
+
+// Simulates a connection over a link with fixed MTU. Drops packets which
+// exceed the MTU and passes the rest of them as-is.
+class LimitedMtuTestWriter : public QuicPacketWriterWrapper {
+ public:
+ explicit LimitedMtuTestWriter(QuicByteCount mtu);
+ LimitedMtuTestWriter(const LimitedMtuTestWriter&) = delete;
+ LimitedMtuTestWriter& operator=(const LimitedMtuTestWriter&) = delete;
+ ~LimitedMtuTestWriter() override;
+
+ // Inherited from QuicPacketWriterWrapper.
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ private:
+ QuicByteCount mtu_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_LIMITED_MTU_TEST_WRITER_H_
diff --git a/quiche/quic/test_tools/mock_clock.cc b/quiche/quic/test_tools/mock_clock.cc
new file mode 100644
index 0000000..6aced9e
--- /dev/null
+++ b/quiche/quic/test_tools/mock_clock.cc
@@ -0,0 +1,33 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_clock.h"
+
+namespace quic {
+
+MockClock::MockClock() : now_(QuicTime::Zero()) {}
+
+MockClock::~MockClock() {}
+
+void MockClock::AdvanceTime(QuicTime::Delta delta) {
+ now_ = now_ + delta;
+}
+
+void MockClock::Reset() {
+ now_ = QuicTime::Zero();
+}
+
+QuicTime MockClock::Now() const {
+ return now_;
+}
+
+QuicTime MockClock::ApproximateNow() const {
+ return now_;
+}
+
+QuicWallTime MockClock::WallNow() const {
+ return QuicWallTime::FromUNIXSeconds((now_ - QuicTime::Zero()).ToSeconds());
+}
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_clock.h b/quiche/quic/test_tools/mock_clock.h
new file mode 100644
index 0000000..cbb08c0
--- /dev/null
+++ b/quiche/quic/test_tools/mock_clock.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_CLOCK_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_CLOCK_H_
+
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_time.h"
+
+namespace quic {
+
+class MockClock : public QuicClock {
+ public:
+ MockClock();
+ MockClock(const MockClock&) = delete;
+ MockClock& operator=(const MockClock&) = delete;
+ ~MockClock() override;
+
+ // QuicClock implementation:
+ QuicTime Now() const override;
+ QuicTime ApproximateNow() const override;
+ QuicWallTime WallNow() const override;
+
+ // Advances the current time by |delta|, which may be negative.
+ void AdvanceTime(QuicTime::Delta delta);
+ // Resets time back to zero.
+ void Reset();
+
+ private:
+ QuicTime now_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_CLOCK_H_
diff --git a/quiche/quic/test_tools/mock_quic_client_promised_info.cc b/quiche/quic/test_tools/mock_quic_client_promised_info.cc
new file mode 100644
index 0000000..9d3a29b
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_client_promised_info.cc
@@ -0,0 +1,19 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_quic_client_promised_info.h"
+
+namespace quic {
+namespace test {
+
+MockQuicClientPromisedInfo::MockQuicClientPromisedInfo(
+ QuicSpdyClientSessionBase* session,
+ QuicStreamId id,
+ std::string url)
+ : QuicClientPromisedInfo(session, id, url) {}
+
+MockQuicClientPromisedInfo::~MockQuicClientPromisedInfo() {}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_quic_client_promised_info.h b/quiche/quic/test_tools/mock_quic_client_promised_info.h
new file mode 100644
index 0000000..42c2100
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_client_promised_info.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_CLIENT_PROMISED_INFO_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_CLIENT_PROMISED_INFO_H_
+
+#include <string>
+
+#include "quiche/quic/core/http/quic_client_promised_info.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class MockQuicClientPromisedInfo : public QuicClientPromisedInfo {
+ public:
+ MockQuicClientPromisedInfo(QuicSpdyClientSessionBase* session,
+ QuicStreamId id,
+ std::string url);
+ ~MockQuicClientPromisedInfo() override;
+
+ MOCK_METHOD(QuicAsyncStatus,
+ HandleClientRequest,
+ (const spdy::SpdyHeaderBlock& headers,
+ QuicClientPushPromiseIndex::Delegate*),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_CLIENT_PROMISED_INFO_H_
diff --git a/quiche/quic/test_tools/mock_quic_dispatcher.cc b/quiche/quic/test_tools/mock_quic_dispatcher.cc
new file mode 100644
index 0000000..501516c
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_dispatcher.cc
@@ -0,0 +1,32 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_quic_dispatcher.h"
+
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+MockQuicDispatcher::MockQuicDispatcher(
+ const QuicConfig* config,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicVersionManager* version_manager,
+ std::unique_ptr<QuicConnectionHelperInterface> helper,
+ std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
+ std::unique_ptr<QuicAlarmFactory> alarm_factory,
+ QuicSimpleServerBackend* quic_simple_server_backend)
+ : QuicSimpleDispatcher(config,
+ crypto_config,
+ version_manager,
+ std::move(helper),
+ std::move(session_helper),
+ std::move(alarm_factory),
+ quic_simple_server_backend,
+ kQuicDefaultConnectionIdLength) {}
+
+MockQuicDispatcher::~MockQuicDispatcher() {}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_quic_dispatcher.h b/quiche/quic/test_tools/mock_quic_dispatcher.h
new file mode 100644
index 0000000..2080d32
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_dispatcher.h
@@ -0,0 +1,44 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_DISPATCHER_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_DISPATCHER_H_
+
+#include "quiche/quic/core/crypto/quic_crypto_server_config.h"
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/tools/quic_simple_dispatcher.h"
+#include "quiche/quic/tools/quic_simple_server_backend.h"
+
+namespace quic {
+namespace test {
+
+class MockQuicDispatcher : public QuicSimpleDispatcher {
+ public:
+ MockQuicDispatcher(
+ const QuicConfig* config,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicVersionManager* version_manager,
+ std::unique_ptr<QuicConnectionHelperInterface> helper,
+ std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
+ std::unique_ptr<QuicAlarmFactory> alarm_factory,
+ QuicSimpleServerBackend* quic_simple_server_backend);
+ MockQuicDispatcher(const MockQuicDispatcher&) = delete;
+ MockQuicDispatcher& operator=(const MockQuicDispatcher&) = delete;
+
+ ~MockQuicDispatcher() override;
+
+ MOCK_METHOD(void,
+ ProcessPacket,
+ (const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const QuicReceivedPacket& packet),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_DISPATCHER_H_
diff --git a/quiche/quic/test_tools/mock_quic_session_visitor.cc b/quiche/quic/test_tools/mock_quic_session_visitor.cc
new file mode 100644
index 0000000..5f1f75a
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_session_visitor.cc
@@ -0,0 +1,19 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_quic_session_visitor.h"
+
+namespace quic {
+namespace test {
+
+MockQuicSessionVisitor::MockQuicSessionVisitor() = default;
+
+MockQuicSessionVisitor::~MockQuicSessionVisitor() = default;
+
+MockQuicCryptoServerStreamHelper::MockQuicCryptoServerStreamHelper() = default;
+
+MockQuicCryptoServerStreamHelper::~MockQuicCryptoServerStreamHelper() = default;
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_quic_session_visitor.h b/quiche/quic/test_tools/mock_quic_session_visitor.h
new file mode 100644
index 0000000..6713851
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_session_visitor.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SESSION_VISITOR_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SESSION_VISITOR_H_
+
+#include "quiche/quic/core/quic_crypto_server_stream_base.h"
+#include "quiche/quic/core/quic_time_wait_list_manager.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class MockQuicSessionVisitor : public QuicTimeWaitListManager::Visitor {
+ public:
+ MockQuicSessionVisitor();
+ MockQuicSessionVisitor(const MockQuicSessionVisitor&) = delete;
+ MockQuicSessionVisitor& operator=(const MockQuicSessionVisitor&) = delete;
+ ~MockQuicSessionVisitor() override;
+ MOCK_METHOD(void,
+ OnConnectionClosed,
+ (QuicConnectionId connection_id,
+ QuicErrorCode error,
+ const std::string& error_details,
+ ConnectionCloseSource source),
+ (override));
+ MOCK_METHOD(void, OnWriteBlocked, (QuicBlockedWriterInterface*), (override));
+ MOCK_METHOD(void,
+ OnRstStreamReceived,
+ (const QuicRstStreamFrame& frame),
+ (override));
+ MOCK_METHOD(void,
+ OnStopSendingReceived,
+ (const QuicStopSendingFrame& frame),
+ (override));
+ MOCK_METHOD(void,
+ OnNewConnectionIdSent,
+ (const QuicConnectionId& server_connection_id,
+ const QuicConnectionId& new_connection_id),
+ (override));
+ MOCK_METHOD(void,
+ OnConnectionIdRetired,
+ (const quic::QuicConnectionId& server_connection_id),
+ (override));
+ MOCK_METHOD(void,
+ OnConnectionAddedToTimeWaitList,
+ (QuicConnectionId connection_id),
+ (override));
+};
+
+class MockQuicCryptoServerStreamHelper
+ : public QuicCryptoServerStreamBase::Helper {
+ public:
+ MockQuicCryptoServerStreamHelper();
+ MockQuicCryptoServerStreamHelper(const MockQuicCryptoServerStreamHelper&) =
+ delete;
+ MockQuicCryptoServerStreamHelper& operator=(
+ const MockQuicCryptoServerStreamHelper&) = delete;
+ ~MockQuicCryptoServerStreamHelper() override;
+ MOCK_METHOD(bool,
+ CanAcceptClientHello,
+ (const CryptoHandshakeMessage& message,
+ const QuicSocketAddress& client_address,
+ const QuicSocketAddress& peer_address,
+ const QuicSocketAddress& self_address,
+ std::string*),
+ (const, override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SESSION_VISITOR_H_
diff --git a/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc b/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc
new file mode 100644
index 0000000..d82d8f5
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc
@@ -0,0 +1,19 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_quic_spdy_client_stream.h"
+
+namespace quic {
+namespace test {
+
+MockQuicSpdyClientStream::MockQuicSpdyClientStream(
+ QuicStreamId id,
+ QuicSpdyClientSession* session,
+ StreamType type)
+ : QuicSpdyClientStream(id, session, type) {}
+
+MockQuicSpdyClientStream::~MockQuicSpdyClientStream() {}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_quic_spdy_client_stream.h b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
new file mode 100644
index 0000000..cc4d87e
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SPDY_CLIENT_STREAM_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SPDY_CLIENT_STREAM_H_
+
+#include "quiche/quic/core/http/quic_header_list.h"
+#include "quiche/quic/core/http/quic_spdy_client_stream.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class MockQuicSpdyClientStream : public QuicSpdyClientStream {
+ public:
+ MockQuicSpdyClientStream(QuicStreamId id,
+ QuicSpdyClientSession* session,
+ StreamType type);
+ ~MockQuicSpdyClientStream() override;
+
+ MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+ MOCK_METHOD(void,
+ OnPromiseHeaderList,
+ (QuicStreamId promised_stream_id,
+ size_t frame_len,
+ const QuicHeaderList& list),
+ (override));
+ MOCK_METHOD(void, OnDataAvailable, (), (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_SPDY_CLIENT_STREAM_H_
diff --git a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc
new file mode 100644
index 0000000..81486d1
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc
@@ -0,0 +1,32 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_quic_time_wait_list_manager.h"
+
+using testing::_;
+using testing::Invoke;
+
+namespace quic {
+namespace test {
+
+MockTimeWaitListManager::MockTimeWaitListManager(
+ QuicPacketWriter* writer,
+ Visitor* visitor,
+ const QuicClock* clock,
+ QuicAlarmFactory* alarm_factory)
+ : QuicTimeWaitListManager(writer, visitor, clock, alarm_factory) {
+ // Though AddConnectionIdToTimeWait is mocked, we want to retain its
+ // functionality.
+ EXPECT_CALL(*this, AddConnectionIdToTimeWait(_, _))
+ .Times(testing::AnyNumber());
+ ON_CALL(*this, AddConnectionIdToTimeWait(_, _))
+ .WillByDefault(
+ Invoke(this, &MockTimeWaitListManager::
+ QuicTimeWaitListManager_AddConnectionIdToTimeWait));
+}
+
+MockTimeWaitListManager::~MockTimeWaitListManager() = default;
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h
new file mode 100644
index 0000000..571c8fa
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h
@@ -0,0 +1,76 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_TIME_WAIT_LIST_MANAGER_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_TIME_WAIT_LIST_MANAGER_H_
+
+#include "quiche/quic/core/quic_time_wait_list_manager.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class MockTimeWaitListManager : public QuicTimeWaitListManager {
+ public:
+ MockTimeWaitListManager(QuicPacketWriter* writer,
+ Visitor* visitor,
+ const QuicClock* clock,
+ QuicAlarmFactory* alarm_factory);
+ ~MockTimeWaitListManager() override;
+
+ MOCK_METHOD(void, AddConnectionIdToTimeWait,
+ (QuicTimeWaitListManager::TimeWaitAction action,
+ quic::TimeWaitConnectionInfo info),
+ (override));
+
+ void QuicTimeWaitListManager_AddConnectionIdToTimeWait(
+ QuicTimeWaitListManager::TimeWaitAction action,
+ quic::TimeWaitConnectionInfo info) {
+ QuicTimeWaitListManager::AddConnectionIdToTimeWait(action, std::move(info));
+ }
+
+ MOCK_METHOD(void,
+ ProcessPacket,
+ (const QuicSocketAddress&,
+ const QuicSocketAddress&,
+ QuicConnectionId,
+ PacketHeaderFormat,
+ size_t,
+ std::unique_ptr<QuicPerPacketContext>),
+ (override));
+
+ MOCK_METHOD(void,
+ SendVersionNegotiationPacket,
+ (QuicConnectionId server_connection_id,
+ QuicConnectionId client_connection_id,
+ bool ietf_quic,
+ bool has_length_prefix,
+ const ParsedQuicVersionVector& supported_versions,
+ const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ std::unique_ptr<QuicPerPacketContext> packet_context),
+ (override));
+
+ MOCK_METHOD(void,
+ SendPublicReset,
+ (const QuicSocketAddress&,
+ const QuicSocketAddress&,
+ QuicConnectionId,
+ bool,
+ size_t,
+ std::unique_ptr<QuicPerPacketContext>),
+ (override));
+
+ MOCK_METHOD(void,
+ SendPacket,
+ (const QuicSocketAddress&,
+ const QuicSocketAddress&,
+ const QuicEncryptedPacket&),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_TIME_WAIT_LIST_MANAGER_H_
diff --git a/quiche/quic/test_tools/mock_random.cc b/quiche/quic/test_tools/mock_random.cc
new file mode 100644
index 0000000..0a61a1c
--- /dev/null
+++ b/quiche/quic/test_tools/mock_random.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/mock_random.h"
+
+#include <string.h>
+
+namespace quic {
+namespace test {
+
+MockRandom::MockRandom() : base_(0xDEADBEEF), increment_(0) {}
+
+MockRandom::MockRandom(uint32_t base) : base_(base), increment_(0) {}
+
+void MockRandom::RandBytes(void* data, size_t len) {
+ memset(data, increment_ + static_cast<uint8_t>('r'), len);
+}
+
+uint64_t MockRandom::RandUint64() {
+ return base_ + increment_;
+}
+
+void MockRandom::InsecureRandBytes(void* data, size_t len) {
+ RandBytes(data, len);
+}
+
+uint64_t MockRandom::InsecureRandUint64() {
+ return RandUint64();
+}
+
+void MockRandom::ChangeValue() {
+ increment_++;
+}
+
+void MockRandom::ResetBase(uint32_t base) {
+ base_ = base;
+ increment_ = 0;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/mock_random.h b/quiche/quic/test_tools/mock_random.h
new file mode 100644
index 0000000..03c1f00
--- /dev/null
+++ b/quiche/quic/test_tools/mock_random.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_MOCK_RANDOM_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_RANDOM_H_
+
+#include "quiche/quic/core/crypto/quic_random.h"
+
+namespace quic {
+namespace test {
+
+class MockRandom : public QuicRandom {
+ public:
+ // Initializes base_ to 0xDEADBEEF.
+ MockRandom();
+ explicit MockRandom(uint32_t base);
+ MockRandom(const MockRandom&) = delete;
+ MockRandom& operator=(const MockRandom&) = delete;
+
+ // QuicRandom:
+ // Fills the |data| buffer with a repeating byte, initially 'r'.
+ void RandBytes(void* data, size_t len) override;
+ // Returns base + the current increment.
+ uint64_t RandUint64() override;
+
+ // InsecureRandBytes behaves equivalently to RandBytes.
+ void InsecureRandBytes(void* data, size_t len) override;
+ // InsecureRandUint64 behaves equivalently to RandUint64.
+ uint64_t InsecureRandUint64() override;
+
+ // ChangeValue increments |increment_|. This causes the value returned by
+ // |RandUint64| and the byte that |RandBytes| fills with, to change.
+ void ChangeValue();
+
+ // Sets the base to |base| and resets increment to zero.
+ void ResetBase(uint32_t base);
+
+ private:
+ uint32_t base_;
+ uint8_t increment_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_RANDOM_H_
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.cc b/quiche/quic/test_tools/packet_dropping_test_writer.cc
new file mode 100644
index 0000000..f90128c
--- /dev/null
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.cc
@@ -0,0 +1,262 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/packet_dropping_test_writer.h"
+
+#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+
+namespace quic {
+namespace test {
+
+// Every dropped packet must be followed by this number of succesfully written
+// packets. This is to avoid flaky test failures and timeouts, for example, in
+// case both the client and the server drop every other packet (which is
+// statistically possible even if drop percentage is less than 50%).
+const int32_t kMinSuccesfulWritesAfterPacketLoss = 2;
+
+// An alarm that is scheduled if a blocked socket is simulated to indicate
+// it's writable again.
+class WriteUnblockedAlarm : public QuicAlarm::DelegateWithoutContext {
+ public:
+ explicit WriteUnblockedAlarm(PacketDroppingTestWriter* writer)
+ : writer_(writer) {}
+
+ void OnAlarm() override {
+ QUIC_DLOG(INFO) << "Unblocking socket.";
+ writer_->OnCanWrite();
+ }
+
+ private:
+ PacketDroppingTestWriter* writer_;
+};
+
+// An alarm that is scheduled every time a new packet is to be written at a
+// later point.
+class DelayAlarm : public QuicAlarm::DelegateWithoutContext {
+ public:
+ explicit DelayAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {}
+
+ void OnAlarm() override {
+ QuicTime new_deadline = writer_->ReleaseOldPackets();
+ if (new_deadline.IsInitialized()) {
+ writer_->SetDelayAlarm(new_deadline);
+ }
+ }
+
+ private:
+ PacketDroppingTestWriter* writer_;
+};
+
+PacketDroppingTestWriter::PacketDroppingTestWriter()
+ : clock_(nullptr),
+ cur_buffer_size_(0),
+ num_calls_to_write_(0),
+ // Do not require any number of successful writes before the first dropped
+ // packet.
+ num_consecutive_succesful_writes_(kMinSuccesfulWritesAfterPacketLoss),
+ fake_packet_loss_percentage_(0),
+ fake_drop_first_n_packets_(0),
+ fake_blocked_socket_percentage_(0),
+ fake_packet_reorder_percentage_(0),
+ fake_packet_delay_(QuicTime::Delta::Zero()),
+ fake_bandwidth_(QuicBandwidth::Zero()),
+ buffer_size_(0) {
+ uint64_t seed = QuicRandom::GetInstance()->RandUint64();
+ QUIC_LOG(INFO) << "Seeding packet loss with " << seed;
+ simple_random_.set_seed(seed);
+}
+
+PacketDroppingTestWriter::~PacketDroppingTestWriter() {
+ if (write_unblocked_alarm_ != nullptr) {
+ write_unblocked_alarm_->PermanentCancel();
+ }
+ if (delay_alarm_ != nullptr) {
+ delay_alarm_->PermanentCancel();
+ }
+}
+
+void PacketDroppingTestWriter::Initialize(
+ QuicConnectionHelperInterface* helper,
+ QuicAlarmFactory* alarm_factory,
+ std::unique_ptr<Delegate> on_can_write) {
+ clock_ = helper->GetClock();
+ write_unblocked_alarm_.reset(
+ alarm_factory->CreateAlarm(new WriteUnblockedAlarm(this)));
+ delay_alarm_.reset(alarm_factory->CreateAlarm(new DelayAlarm(this)));
+ on_can_write_ = std::move(on_can_write);
+}
+
+WriteResult PacketDroppingTestWriter::WritePacket(
+ const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) {
+ ++num_calls_to_write_;
+ ReleaseOldPackets();
+
+ QuicWriterMutexLock lock(&config_mutex_);
+ if (fake_drop_first_n_packets_ > 0 &&
+ num_calls_to_write_ <=
+ static_cast<uint64_t>(fake_drop_first_n_packets_)) {
+ QUIC_DVLOG(1) << "Dropping first " << fake_drop_first_n_packets_
+ << " packets (packet number " << num_calls_to_write_ << ")";
+ num_consecutive_succesful_writes_ = 0;
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ }
+
+ // Drop every packet at 100%, otherwise always succeed for at least
+ // kMinSuccesfulWritesAfterPacketLoss packets between two dropped ones.
+ if (fake_packet_loss_percentage_ == 100 ||
+ (fake_packet_loss_percentage_ > 0 &&
+ num_consecutive_succesful_writes_ >=
+ kMinSuccesfulWritesAfterPacketLoss &&
+ (simple_random_.RandUint64() % 100 <
+ static_cast<uint64_t>(fake_packet_loss_percentage_)))) {
+ QUIC_DVLOG(1) << "Dropping packet " << num_calls_to_write_;
+ num_consecutive_succesful_writes_ = 0;
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ } else {
+ ++num_consecutive_succesful_writes_;
+ }
+
+ if (fake_blocked_socket_percentage_ > 0 &&
+ simple_random_.RandUint64() % 100 <
+ static_cast<uint64_t>(fake_blocked_socket_percentage_)) {
+ QUICHE_CHECK(on_can_write_ != nullptr);
+ QUIC_DVLOG(1) << "Blocking socket for packet " << num_calls_to_write_;
+ if (!write_unblocked_alarm_->IsSet()) {
+ // Set the alarm to fire immediately.
+ write_unblocked_alarm_->Set(clock_->ApproximateNow());
+ }
+
+ // Dropping this packet on retry could result in PTO timeout,
+ // make sure to avoid this.
+ num_consecutive_succesful_writes_ = 0;
+
+ return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN);
+ }
+
+ if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) {
+ if (buffer_size_ > 0 && buf_len + cur_buffer_size_ > buffer_size_) {
+ // Drop packets which do not fit into the buffer.
+ QUIC_DVLOG(1) << "Dropping packet because the buffer is full.";
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ }
+
+ // Queue it to be sent.
+ QuicTime send_time = clock_->ApproximateNow() + fake_packet_delay_;
+ if (!fake_bandwidth_.IsZero()) {
+ // Calculate a time the bandwidth limit would impose.
+ QuicTime::Delta bandwidth_delay = QuicTime::Delta::FromMicroseconds(
+ (buf_len * kNumMicrosPerSecond) / fake_bandwidth_.ToBytesPerSecond());
+ send_time = delayed_packets_.empty()
+ ? send_time + bandwidth_delay
+ : delayed_packets_.back().send_time + bandwidth_delay;
+ }
+ std::unique_ptr<PerPacketOptions> delayed_options;
+ if (options != nullptr) {
+ delayed_options = options->Clone();
+ }
+ delayed_packets_.push_back(
+ DelayedWrite(buffer, buf_len, self_address, peer_address,
+ std::move(delayed_options), send_time));
+ cur_buffer_size_ += buf_len;
+
+ // Set the alarm if it's not yet set.
+ if (!delay_alarm_->IsSet()) {
+ delay_alarm_->Set(send_time);
+ }
+
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+ }
+
+ return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
+ peer_address, options);
+}
+
+bool PacketDroppingTestWriter::IsWriteBlocked() const {
+ if (write_unblocked_alarm_ != nullptr && write_unblocked_alarm_->IsSet()) {
+ return true;
+ }
+ return QuicPacketWriterWrapper::IsWriteBlocked();
+}
+
+void PacketDroppingTestWriter::SetWritable() {
+ if (write_unblocked_alarm_ != nullptr && write_unblocked_alarm_->IsSet()) {
+ write_unblocked_alarm_->Cancel();
+ }
+ QuicPacketWriterWrapper::SetWritable();
+}
+
+QuicTime PacketDroppingTestWriter::ReleaseNextPacket() {
+ if (delayed_packets_.empty()) {
+ return QuicTime::Zero();
+ }
+ QuicReaderMutexLock lock(&config_mutex_);
+ auto iter = delayed_packets_.begin();
+ // Determine if we should re-order.
+ if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 &&
+ simple_random_.RandUint64() % 100 <
+ static_cast<uint64_t>(fake_packet_reorder_percentage_)) {
+ QUIC_DLOG(INFO) << "Reordering packets.";
+ ++iter;
+ // Swap the send times when re-ordering packets.
+ delayed_packets_.begin()->send_time = iter->send_time;
+ }
+
+ QUIC_DVLOG(1) << "Releasing packet. " << (delayed_packets_.size() - 1)
+ << " remaining.";
+ // Grab the next one off the queue and send it.
+ QuicPacketWriterWrapper::WritePacket(
+ iter->buffer.data(), iter->buffer.length(), iter->self_address,
+ iter->peer_address, iter->options.get());
+ QUICHE_DCHECK_GE(cur_buffer_size_, iter->buffer.length());
+ cur_buffer_size_ -= iter->buffer.length();
+ delayed_packets_.erase(iter);
+
+ // If there are others, find the time for the next to be sent.
+ if (delayed_packets_.empty()) {
+ return QuicTime::Zero();
+ }
+ return delayed_packets_.begin()->send_time;
+}
+
+QuicTime PacketDroppingTestWriter::ReleaseOldPackets() {
+ while (!delayed_packets_.empty()) {
+ QuicTime next_send_time = delayed_packets_.front().send_time;
+ if (next_send_time > clock_->Now()) {
+ return next_send_time;
+ }
+ ReleaseNextPacket();
+ }
+ return QuicTime::Zero();
+}
+
+void PacketDroppingTestWriter::SetDelayAlarm(QuicTime new_deadline) {
+ delay_alarm_->Set(new_deadline);
+}
+
+void PacketDroppingTestWriter::OnCanWrite() {
+ on_can_write_->OnCanWrite();
+}
+
+PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
+ const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ std::unique_ptr<PerPacketOptions> options,
+ QuicTime send_time)
+ : buffer(buffer, buf_len),
+ self_address(self_address),
+ peer_address(peer_address),
+ options(std::move(options)),
+ send_time(send_time) {}
+
+PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() = default;
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.h b/quiche/quic/test_tools/packet_dropping_test_writer.h
new file mode 100644
index 0000000..40204d9
--- /dev/null
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.h
@@ -0,0 +1,186 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_
+#define QUICHE_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_
+
+#include <cstdint>
+#include <list>
+#include <memory>
+
+#include "absl/base/attributes.h"
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+#include "quiche/quic/test_tools/quic_test_client.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+// Simulates a connection that drops packets a configured percentage of the time
+// and has a blocked socket a configured percentage of the time. Also provides
+// the options to delay packets and reorder packets if delay is enabled.
+class PacketDroppingTestWriter : public QuicPacketWriterWrapper {
+ public:
+ class Delegate {
+ public:
+ virtual ~Delegate() {}
+ virtual void OnCanWrite() = 0;
+ };
+
+ PacketDroppingTestWriter();
+ PacketDroppingTestWriter(const PacketDroppingTestWriter&) = delete;
+ PacketDroppingTestWriter& operator=(const PacketDroppingTestWriter&) = delete;
+
+ ~PacketDroppingTestWriter() override;
+
+ // Must be called before blocking, reordering or delaying (loss is OK). May be
+ // called after connecting if the helper is not available before.
+ // |on_can_write| will be triggered when fake-unblocking.
+ void Initialize(QuicConnectionHelperInterface* helper,
+ QuicAlarmFactory* alarm_factory,
+ std::unique_ptr<Delegate> on_can_write);
+
+ // QuicPacketWriter methods:
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ bool IsWriteBlocked() const override;
+
+ void SetWritable() override;
+
+ QuicPacketBuffer GetNextWriteLocation(
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/) override {
+ // If the wrapped writer supports zero-copy, disable it, because it is not
+ // compatible with delayed writes in this class.
+ return {nullptr, nullptr};
+ }
+
+ // Writes out any packet which should have been sent by now
+ // to the contained writer and returns the time
+ // for the next delayed packet to be written.
+ QuicTime ReleaseOldPackets();
+
+ // Sets |delay_alarm_| to fire at |new_deadline|.
+ void SetDelayAlarm(QuicTime new_deadline);
+
+ void OnCanWrite();
+
+ // The percent of time a packet is simulated as being lost.
+ // If |fake_packet_loss_percentage| is 100, then all packages are lost.
+ // Otherwise actual percentage will be lower than
+ // |fake_packet_loss_percentage|, because every dropped package is followed by
+ // a minimum number of successfully written packets.
+ void set_fake_packet_loss_percentage(int32_t fake_packet_loss_percentage) {
+ QuicWriterMutexLock lock(&config_mutex_);
+ fake_packet_loss_percentage_ = fake_packet_loss_percentage;
+ }
+
+ // Simulate dropping the first n packets unconditionally.
+ // Subsequent packets will be lost at fake_packet_loss_percentage_ if set.
+ void set_fake_drop_first_n_packets(int32_t fake_drop_first_n_packets) {
+ QuicWriterMutexLock lock(&config_mutex_);
+ fake_drop_first_n_packets_ = fake_drop_first_n_packets;
+ }
+
+ // The percent of time WritePacket will block and set WriteResult's status
+ // to WRITE_STATUS_BLOCKED.
+ void set_fake_blocked_socket_percentage(
+ int32_t fake_blocked_socket_percentage) {
+ QUICHE_DCHECK(clock_);
+ QuicWriterMutexLock lock(&config_mutex_);
+ fake_blocked_socket_percentage_ = fake_blocked_socket_percentage;
+ }
+
+ // The percent of time a packet is simulated as being reordered.
+ void set_fake_reorder_percentage(int32_t fake_packet_reorder_percentage) {
+ QUICHE_DCHECK(clock_);
+ QuicWriterMutexLock lock(&config_mutex_);
+ QUICHE_DCHECK(!fake_packet_delay_.IsZero());
+ fake_packet_reorder_percentage_ = fake_packet_reorder_percentage;
+ }
+
+ // The delay before writing this packet.
+ void set_fake_packet_delay(QuicTime::Delta fake_packet_delay) {
+ QUICHE_DCHECK(clock_);
+ QuicWriterMutexLock lock(&config_mutex_);
+ fake_packet_delay_ = fake_packet_delay;
+ }
+
+ // The maximum bandwidth and buffer size of the connection. When these are
+ // set, packets will be delayed until a connection with that bandwidth would
+ // transmit it. Once the |buffer_size| is reached, all new packets are
+ // dropped.
+ void set_max_bandwidth_and_buffer_size(QuicBandwidth fake_bandwidth,
+ QuicByteCount buffer_size) {
+ QUICHE_DCHECK(clock_);
+ QuicWriterMutexLock lock(&config_mutex_);
+ fake_bandwidth_ = fake_bandwidth;
+ buffer_size_ = buffer_size;
+ }
+
+ // Useful for reproducing very flaky issues.
+ ABSL_ATTRIBUTE_UNUSED void set_seed(uint64_t seed) {
+ simple_random_.set_seed(seed);
+ }
+
+ private:
+ // Writes out the next packet to the contained writer and returns the time
+ // for the next delayed packet to be written.
+ QuicTime ReleaseNextPacket();
+
+ // A single packet which will be sent at the supplied send_time.
+ struct DelayedWrite {
+ public:
+ DelayedWrite(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ std::unique_ptr<PerPacketOptions> options,
+ QuicTime send_time);
+ DelayedWrite(const DelayedWrite&) = delete;
+ DelayedWrite(DelayedWrite&&) = default;
+ DelayedWrite& operator=(const DelayedWrite&) = delete;
+ DelayedWrite& operator=(DelayedWrite&&) = default;
+ ~DelayedWrite();
+
+ std::string buffer;
+ QuicIpAddress self_address;
+ QuicSocketAddress peer_address;
+ std::unique_ptr<PerPacketOptions> options;
+ QuicTime send_time;
+ };
+
+ using DelayedPacketList = std::list<DelayedWrite>;
+
+ const QuicClock* clock_;
+ std::unique_ptr<QuicAlarm> write_unblocked_alarm_;
+ std::unique_ptr<QuicAlarm> delay_alarm_;
+ std::unique_ptr<Delegate> on_can_write_;
+ SimpleRandom simple_random_;
+ // Stored packets delayed by fake packet delay or bandwidth restrictions.
+ DelayedPacketList delayed_packets_;
+ QuicByteCount cur_buffer_size_;
+ uint64_t num_calls_to_write_;
+ int32_t num_consecutive_succesful_writes_;
+
+ QuicMutex config_mutex_;
+ int32_t fake_packet_loss_percentage_ QUIC_GUARDED_BY(config_mutex_);
+ int32_t fake_drop_first_n_packets_ QUIC_GUARDED_BY(config_mutex_);
+ int32_t fake_blocked_socket_percentage_ QUIC_GUARDED_BY(config_mutex_);
+ int32_t fake_packet_reorder_percentage_ QUIC_GUARDED_BY(config_mutex_);
+ QuicTime::Delta fake_packet_delay_ QUIC_GUARDED_BY(config_mutex_);
+ QuicBandwidth fake_bandwidth_ QUIC_GUARDED_BY(config_mutex_);
+ QuicByteCount buffer_size_ QUIC_GUARDED_BY(config_mutex_);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_
diff --git a/quiche/quic/test_tools/packet_reordering_writer.cc b/quiche/quic/test_tools/packet_reordering_writer.cc
new file mode 100644
index 0000000..66073ea
--- /dev/null
+++ b/quiche/quic/test_tools/packet_reordering_writer.cc
@@ -0,0 +1,54 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/packet_reordering_writer.h"
+
+namespace quic {
+namespace test {
+
+PacketReorderingWriter::PacketReorderingWriter() = default;
+
+PacketReorderingWriter::~PacketReorderingWriter() = default;
+
+WriteResult PacketReorderingWriter::WritePacket(
+ const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) {
+ if (!delay_next_) {
+ QUIC_VLOG(2) << "Writing a non-delayed packet";
+ WriteResult wr = QuicPacketWriterWrapper::WritePacket(
+ buffer, buf_len, self_address, peer_address, options);
+ --num_packets_to_wait_;
+ if (num_packets_to_wait_ == 0) {
+ QUIC_VLOG(2) << "Writing a delayed packet";
+ // It's time to write the delayed packet.
+ QuicPacketWriterWrapper::WritePacket(
+ delayed_data_.data(), delayed_data_.length(), delayed_self_address_,
+ delayed_peer_address_, delayed_options_.get());
+ }
+ return wr;
+ }
+ // Still have packet to wait.
+ QUICHE_DCHECK_LT(0u, num_packets_to_wait_)
+ << "Only allow one packet to be delayed";
+ delayed_data_ = std::string(buffer, buf_len);
+ delayed_self_address_ = self_address;
+ delayed_peer_address_ = peer_address;
+ if (options != nullptr) {
+ delayed_options_ = options->Clone();
+ }
+ delay_next_ = false;
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+}
+
+void PacketReorderingWriter::SetDelay(size_t num_packets_to_wait) {
+ QUICHE_DCHECK_GT(num_packets_to_wait, 0u);
+ num_packets_to_wait_ = num_packets_to_wait;
+ delay_next_ = true;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/packet_reordering_writer.h b/quiche/quic/test_tools/packet_reordering_writer.h
new file mode 100644
index 0000000..9906cd0
--- /dev/null
+++ b/quiche/quic/test_tools/packet_reordering_writer.h
@@ -0,0 +1,45 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_PACKET_REORDERING_WRITER_H_
+#define QUICHE_QUIC_TEST_TOOLS_PACKET_REORDERING_WRITER_H_
+
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+
+namespace quic {
+
+namespace test {
+
+// This packet writer allows delaying writing the next packet after
+// SetDelay(num_packets_to_wait)
+// is called and buffer this packet and write it after it writes next
+// |num_packets_to_wait| packets. It doesn't support delaying a packet while
+// there is already a packet delayed.
+class PacketReorderingWriter : public QuicPacketWriterWrapper {
+ public:
+ PacketReorderingWriter();
+
+ ~PacketReorderingWriter() override;
+
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ void SetDelay(size_t num_packets_to_wait);
+
+ private:
+ bool delay_next_ = false;
+ size_t num_packets_to_wait_ = 0;
+ std::string delayed_data_;
+ QuicIpAddress delayed_self_address_;
+ QuicSocketAddress delayed_peer_address_;
+ std::unique_ptr<PerPacketOptions> delayed_options_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_PACKET_REORDERING_WRITER_H_
diff --git a/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.cc b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.cc
new file mode 100644
index 0000000..1b234a1
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.cc
@@ -0,0 +1,90 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+void NoopEncoderStreamErrorDelegate::OnEncoderStreamError(
+ QuicErrorCode /* error_code */,
+ absl::string_view /*error_message*/) {}
+
+TestHeadersHandler::TestHeadersHandler()
+ : decoding_completed_(false), decoding_error_detected_(false) {}
+
+void TestHeadersHandler::OnHeaderDecoded(absl::string_view name,
+ absl::string_view value) {
+ ASSERT_FALSE(decoding_completed_);
+ ASSERT_FALSE(decoding_error_detected_);
+
+ header_list_.AppendValueOrAddHeader(name, value);
+}
+
+void TestHeadersHandler::OnDecodingCompleted() {
+ ASSERT_FALSE(decoding_completed_);
+ ASSERT_FALSE(decoding_error_detected_);
+
+ decoding_completed_ = true;
+}
+
+void TestHeadersHandler::OnDecodingErrorDetected(
+ QuicErrorCode /*error_code*/, absl::string_view error_message) {
+ ASSERT_FALSE(decoding_completed_);
+ ASSERT_FALSE(decoding_error_detected_);
+
+ decoding_error_detected_ = true;
+ error_message_.assign(error_message.data(), error_message.size());
+}
+
+spdy::Http2HeaderBlock TestHeadersHandler::ReleaseHeaderList() {
+ QUICHE_DCHECK(decoding_completed_);
+ QUICHE_DCHECK(!decoding_error_detected_);
+
+ return std::move(header_list_);
+}
+
+bool TestHeadersHandler::decoding_completed() const {
+ return decoding_completed_;
+}
+
+bool TestHeadersHandler::decoding_error_detected() const {
+ return decoding_error_detected_;
+}
+
+const std::string& TestHeadersHandler::error_message() const {
+ QUICHE_DCHECK(decoding_error_detected_);
+ return error_message_;
+}
+
+void QpackDecode(
+ uint64_t maximum_dynamic_table_capacity,
+ uint64_t maximum_blocked_streams,
+ QpackDecoder::EncoderStreamErrorDelegate* encoder_stream_error_delegate,
+ QpackStreamSenderDelegate* decoder_stream_sender_delegate,
+ QpackProgressiveDecoder::HeadersHandlerInterface* handler,
+ const FragmentSizeGenerator& fragment_size_generator,
+ absl::string_view data) {
+ QpackDecoder decoder(maximum_dynamic_table_capacity, maximum_blocked_streams,
+ encoder_stream_error_delegate);
+ decoder.set_qpack_stream_sender_delegate(decoder_stream_sender_delegate);
+ auto progressive_decoder =
+ decoder.CreateProgressiveDecoder(/* stream_id = */ 1, handler);
+ while (!data.empty()) {
+ size_t fragment_size = std::min(fragment_size_generator(), data.size());
+ progressive_decoder->Decode(data.substr(0, fragment_size));
+ data = data.substr(fragment_size);
+ }
+ progressive_decoder->EndHeaderBlock();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h
new file mode 100644
index 0000000..5c1b4f1
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -0,0 +1,115 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_DECODER_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_DECODER_TEST_UTILS_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/qpack/qpack_decoder.h"
+#include "quiche/quic/core/qpack/qpack_progressive_decoder.h"
+#include "quiche/quic/core/quic_error_codes.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
+#include "quiche/spdy/core/spdy_header_block.h"
+
+namespace quic {
+namespace test {
+
+// QpackDecoder::EncoderStreamErrorDelegate implementation that does nothing.
+class NoopEncoderStreamErrorDelegate
+ : public QpackDecoder::EncoderStreamErrorDelegate {
+ public:
+ ~NoopEncoderStreamErrorDelegate() override = default;
+
+ void OnEncoderStreamError(QuicErrorCode error_code,
+ absl::string_view error_message) override;
+};
+
+// Mock QpackDecoder::EncoderStreamErrorDelegate implementation.
+class MockEncoderStreamErrorDelegate
+ : public QpackDecoder::EncoderStreamErrorDelegate {
+ public:
+ ~MockEncoderStreamErrorDelegate() override = default;
+
+ MOCK_METHOD(void,
+ OnEncoderStreamError,
+ (QuicErrorCode error_code, absl::string_view error_message),
+ (override));
+};
+
+// HeadersHandlerInterface implementation that collects decoded headers
+// into a Http2HeaderBlock.
+class TestHeadersHandler
+ : public QpackProgressiveDecoder::HeadersHandlerInterface {
+ public:
+ TestHeadersHandler();
+ ~TestHeadersHandler() override = default;
+
+ // HeadersHandlerInterface implementation:
+ void OnHeaderDecoded(absl::string_view name,
+ absl::string_view value) override;
+ void OnDecodingCompleted() override;
+ void OnDecodingErrorDetected(QuicErrorCode error_code,
+ absl::string_view error_message) override;
+
+ // Release decoded header list. Must only be called if decoding is complete
+ // and no errors have been detected.
+ spdy::Http2HeaderBlock ReleaseHeaderList();
+
+ bool decoding_completed() const;
+ bool decoding_error_detected() const;
+ const std::string& error_message() const;
+
+ private:
+ spdy::Http2HeaderBlock header_list_;
+ bool decoding_completed_;
+ bool decoding_error_detected_;
+ std::string error_message_;
+};
+
+class MockHeadersHandler
+ : public QpackProgressiveDecoder::HeadersHandlerInterface {
+ public:
+ MockHeadersHandler() = default;
+ MockHeadersHandler(const MockHeadersHandler&) = delete;
+ MockHeadersHandler& operator=(const MockHeadersHandler&) = delete;
+ ~MockHeadersHandler() override = default;
+
+ MOCK_METHOD(void,
+ OnHeaderDecoded,
+ (absl::string_view name, absl::string_view value),
+ (override));
+ MOCK_METHOD(void, OnDecodingCompleted, (), (override));
+ MOCK_METHOD(void, OnDecodingErrorDetected,
+ (QuicErrorCode error_code, absl::string_view error_message),
+ (override));
+};
+
+class NoOpHeadersHandler
+ : public QpackProgressiveDecoder::HeadersHandlerInterface {
+ public:
+ ~NoOpHeadersHandler() override = default;
+
+ void OnHeaderDecoded(absl::string_view /*name*/,
+ absl::string_view /*value*/) override {}
+ void OnDecodingCompleted() override {}
+ void OnDecodingErrorDetected(QuicErrorCode /*error_code*/,
+ absl::string_view /*error_message*/) override {}
+};
+
+void QpackDecode(
+ uint64_t maximum_dynamic_table_capacity,
+ uint64_t maximum_blocked_streams,
+ QpackDecoder::EncoderStreamErrorDelegate* encoder_stream_error_delegate,
+ QpackStreamSenderDelegate* decoder_stream_sender_delegate,
+ QpackProgressiveDecoder::HeadersHandlerInterface* handler,
+ const FragmentSizeGenerator& fragment_size_generator,
+ absl::string_view data);
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_DECODER_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/qpack/qpack_encoder_peer.cc b/quiche/quic/test_tools/qpack/qpack_encoder_peer.cc
new file mode 100644
index 0000000..7389437
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_encoder_peer.cc
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/qpack/qpack_encoder_peer.h"
+
+#include "quiche/quic/core/qpack/qpack_encoder.h"
+
+namespace quic {
+namespace test {
+
+// static
+QpackEncoderHeaderTable* QpackEncoderPeer::header_table(QpackEncoder* encoder) {
+ return &encoder->header_table_;
+}
+
+// static
+uint64_t QpackEncoderPeer::maximum_blocked_streams(
+ const QpackEncoder* encoder) {
+ return encoder->maximum_blocked_streams_;
+}
+
+// static
+uint64_t QpackEncoderPeer::smallest_blocking_index(
+ const QpackEncoder* encoder) {
+ return encoder->blocking_manager_.smallest_blocking_index();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/qpack/qpack_encoder_peer.h b/quiche/quic/test_tools/qpack/qpack_encoder_peer.h
new file mode 100644
index 0000000..94a308a
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_encoder_peer.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_PEER_H_
+
+#include <cstdint>
+
+namespace quic {
+
+class QpackEncoder;
+class QpackEncoderHeaderTable;
+
+namespace test {
+
+class QpackEncoderPeer {
+ public:
+ QpackEncoderPeer() = delete;
+
+ static QpackEncoderHeaderTable* header_table(QpackEncoder* encoder);
+ static uint64_t maximum_blocked_streams(const QpackEncoder* encoder);
+ static uint64_t smallest_blocking_index(const QpackEncoder* encoder);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_PEER_H_
diff --git a/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.cc b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.cc
new file mode 100644
index 0000000..ad357a1
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.cc
@@ -0,0 +1,18 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h"
+
+#include "absl/strings/string_view.h"
+#include "quiche/spdy/core/hpack/hpack_encoder.h"
+
+namespace quic {
+namespace test {
+
+void NoopDecoderStreamErrorDelegate::OnDecoderStreamError(
+ QuicErrorCode /*error_code*/,
+ absl::string_view /*error_message*/) {}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h
new file mode 100644
index 0000000..93d242c
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_TEST_UTILS_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/qpack/qpack_encoder.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
+#include "quiche/spdy/core/spdy_header_block.h"
+
+namespace quic {
+namespace test {
+
+// QpackEncoder::DecoderStreamErrorDelegate implementation that does nothing.
+class NoopDecoderStreamErrorDelegate
+ : public QpackEncoder::DecoderStreamErrorDelegate {
+ public:
+ ~NoopDecoderStreamErrorDelegate() override = default;
+
+ void OnDecoderStreamError(QuicErrorCode error_code,
+ absl::string_view error_message) override;
+};
+
+// Mock QpackEncoder::DecoderStreamErrorDelegate implementation.
+class MockDecoderStreamErrorDelegate
+ : public QpackEncoder::DecoderStreamErrorDelegate {
+ public:
+ ~MockDecoderStreamErrorDelegate() override = default;
+
+ MOCK_METHOD(void,
+ OnDecoderStreamError,
+ (QuicErrorCode error_code, absl::string_view error_message),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_ENCODER_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc b/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc
new file mode 100644
index 0000000..9901a70
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -0,0 +1,336 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Decoder to test QPACK Offline Interop corpus
+//
+// See https://github.com/quicwg/base-drafts/wiki/QPACK-Offline-Interop for
+// description of test data format.
+//
+// Example usage
+//
+// cd $TEST_DATA
+// git clone https://github.com/qpackers/qifs.git
+// TEST_ENCODED_DATA=$TEST_DATA/qifs/encoded/qpack-06
+// TEST_QIF_DATA=$TEST_DATA/qifs/qifs
+// $BIN/qpack_offline_decoder \
+// $TEST_ENCODED_DATA/f5/fb-req.qifencoded.4096.100.0 \
+// $TEST_QIF_DATA/fb-req.qif
+// $TEST_ENCODED_DATA/h2o/fb-req-hq.out.512.0.1 \
+// $TEST_QIF_DATA/fb-req-hq.qif
+// $TEST_ENCODED_DATA/ls-qpack/fb-resp-hq.out.0.0.0 \
+// $TEST_QIF_DATA/fb-resp-hq.qif
+// $TEST_ENCODED_DATA/proxygen/netbsd.qif.proxygen.out.4096.0.0 \
+// $TEST_QIF_DATA/netbsd.qif
+//
+
+#include "quiche/quic/test_tools/qpack/qpack_offline_decoder.h"
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
+#include "quiche/common/platform/api/quiche_file_utils.h"
+#include "quiche/common/quiche_endian.h"
+
+namespace quic {
+
+QpackOfflineDecoder::QpackOfflineDecoder()
+ : encoder_stream_error_detected_(false) {}
+
+bool QpackOfflineDecoder::DecodeAndVerifyOfflineData(
+ absl::string_view input_filename,
+ absl::string_view expected_headers_filename) {
+ if (!ParseInputFilename(input_filename)) {
+ QUIC_LOG(ERROR) << "Error parsing input filename " << input_filename;
+ return false;
+ }
+
+ if (!DecodeHeaderBlocksFromFile(input_filename)) {
+ QUIC_LOG(ERROR) << "Error decoding header blocks in " << input_filename;
+ return false;
+ }
+
+ if (!VerifyDecodedHeaderLists(expected_headers_filename)) {
+ QUIC_LOG(ERROR) << "Header lists decoded from " << input_filename
+ << " to not match expected headers parsed from "
+ << expected_headers_filename;
+ return false;
+ }
+
+ return true;
+}
+
+void QpackOfflineDecoder::OnEncoderStreamError(
+ QuicErrorCode error_code, absl::string_view error_message) {
+ QUIC_LOG(ERROR) << "Encoder stream error: "
+ << QuicErrorCodeToString(error_code) << " " << error_message;
+ encoder_stream_error_detected_ = true;
+}
+
+bool QpackOfflineDecoder::ParseInputFilename(absl::string_view input_filename) {
+ std::vector<absl::string_view> pieces = absl::StrSplit(input_filename, '.');
+
+ if (pieces.size() < 3) {
+ QUIC_LOG(ERROR) << "Not enough fields in input filename " << input_filename;
+ return false;
+ }
+
+ auto piece_it = pieces.rbegin();
+
+ // Acknowledgement mode: 1 for immediate, 0 for none.
+ if (*piece_it != "0" && *piece_it != "1") {
+ QUIC_LOG(ERROR)
+ << "Header acknowledgement field must be 0 or 1 in input filename "
+ << input_filename;
+ return false;
+ }
+
+ ++piece_it;
+
+ // Maximum allowed number of blocked streams.
+ uint64_t max_blocked_streams = 0;
+ if (!absl::SimpleAtoi(*piece_it, &max_blocked_streams)) {
+ QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
+ << "\" as an integer.";
+ return false;
+ }
+
+ ++piece_it;
+
+ // Maximum Dynamic Table Capacity in bytes
+ uint64_t maximum_dynamic_table_capacity = 0;
+ if (!absl::SimpleAtoi(*piece_it, &maximum_dynamic_table_capacity)) {
+ QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
+ << "\" as an integer.";
+ return false;
+ }
+ qpack_decoder_ = std::make_unique<QpackDecoder>(
+ maximum_dynamic_table_capacity, max_blocked_streams, this);
+ qpack_decoder_->set_qpack_stream_sender_delegate(
+ &decoder_stream_sender_delegate_);
+
+ // The initial dynamic table capacity is zero according to
+ // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#eviction.
+ // However, for historical reasons, offline interop encoders use
+ // |maximum_dynamic_table_capacity| as initial capacity.
+ qpack_decoder_->OnSetDynamicTableCapacity(maximum_dynamic_table_capacity);
+
+ return true;
+}
+
+bool QpackOfflineDecoder::DecodeHeaderBlocksFromFile(
+ absl::string_view input_filename) {
+ // Store data in |input_data_storage|; use a absl::string_view to
+ // efficiently keep track of remaining portion yet to be decoded.
+ absl::optional<std::string> input_data_storage =
+ quiche::ReadFileContents(input_filename);
+ QUICHE_DCHECK(input_data_storage.has_value());
+ absl::string_view input_data(*input_data_storage);
+
+ while (!input_data.empty()) {
+ // Parse stream_id and length.
+ if (input_data.size() < sizeof(uint64_t) + sizeof(uint32_t)) {
+ QUIC_LOG(ERROR) << "Unexpected end of input file.";
+ return false;
+ }
+
+ uint64_t stream_id = quiche::QuicheEndian::NetToHost64(
+ *reinterpret_cast<const uint64_t*>(input_data.data()));
+ input_data = input_data.substr(sizeof(uint64_t));
+
+ uint32_t length = quiche::QuicheEndian::NetToHost32(
+ *reinterpret_cast<const uint32_t*>(input_data.data()));
+ input_data = input_data.substr(sizeof(uint32_t));
+
+ if (input_data.size() < length) {
+ QUIC_LOG(ERROR) << "Unexpected end of input file.";
+ return false;
+ }
+
+ // Parse data.
+ absl::string_view data = input_data.substr(0, length);
+ input_data = input_data.substr(length);
+
+ // Process data.
+ if (stream_id == 0) {
+ qpack_decoder_->encoder_stream_receiver()->Decode(data);
+
+ if (encoder_stream_error_detected_) {
+ QUIC_LOG(ERROR) << "Error detected on encoder stream.";
+ return false;
+ }
+ } else {
+ auto headers_handler = std::make_unique<test::TestHeadersHandler>();
+ auto progressive_decoder = qpack_decoder_->CreateProgressiveDecoder(
+ stream_id, headers_handler.get());
+
+ progressive_decoder->Decode(data);
+ progressive_decoder->EndHeaderBlock();
+
+ if (headers_handler->decoding_error_detected()) {
+ QUIC_LOG(ERROR) << "Sync decoding error on stream " << stream_id << ": "
+ << headers_handler->error_message();
+ return false;
+ }
+
+ decoders_.push_back({std::move(headers_handler),
+ std::move(progressive_decoder), stream_id});
+ }
+
+ // Move decoded header lists from TestHeadersHandlers and append them to
+ // |decoded_header_lists_| while preserving the order in |decoders_|.
+ while (!decoders_.empty() &&
+ decoders_.front().headers_handler->decoding_completed()) {
+ Decoder* decoder = &decoders_.front();
+
+ if (decoder->headers_handler->decoding_error_detected()) {
+ QUIC_LOG(ERROR) << "Async decoding error on stream "
+ << decoder->stream_id << ": "
+ << decoder->headers_handler->error_message();
+ return false;
+ }
+
+ if (!decoder->headers_handler->decoding_completed()) {
+ QUIC_LOG(ERROR) << "Decoding incomplete after reading entire"
+ " file, on stream "
+ << decoder->stream_id;
+ return false;
+ }
+
+ decoded_header_lists_.push_back(
+ decoder->headers_handler->ReleaseHeaderList());
+ decoders_.pop_front();
+ }
+ }
+
+ if (!decoders_.empty()) {
+ QUICHE_DCHECK(!decoders_.front().headers_handler->decoding_completed());
+
+ QUIC_LOG(ERROR) << "Blocked decoding uncomplete after reading entire"
+ " file, on stream "
+ << decoders_.front().stream_id;
+ return false;
+ }
+
+ return true;
+}
+
+bool QpackOfflineDecoder::VerifyDecodedHeaderLists(
+ absl::string_view expected_headers_filename) {
+ // Store data in |expected_headers_data_storage|; use a
+ // absl::string_view to efficiently keep track of remaining portion
+ // yet to be decoded.
+ absl::optional<std::string> expected_headers_data_storage =
+ quiche::ReadFileContents(expected_headers_filename);
+ QUICHE_DCHECK(expected_headers_data_storage.has_value());
+ absl::string_view expected_headers_data(*expected_headers_data_storage);
+
+ while (!decoded_header_lists_.empty()) {
+ spdy::Http2HeaderBlock decoded_header_list =
+ std::move(decoded_header_lists_.front());
+ decoded_header_lists_.pop_front();
+
+ spdy::Http2HeaderBlock expected_header_list;
+ if (!ReadNextExpectedHeaderList(&expected_headers_data,
+ &expected_header_list)) {
+ QUIC_LOG(ERROR)
+ << "Error parsing expected header list to match next decoded "
+ "header list.";
+ return false;
+ }
+
+ if (!CompareHeaderBlocks(std::move(decoded_header_list),
+ std::move(expected_header_list))) {
+ QUIC_LOG(ERROR) << "Decoded header does not match expected header.";
+ return false;
+ }
+ }
+
+ if (!expected_headers_data.empty()) {
+ QUIC_LOG(ERROR)
+ << "Not enough encoded header lists to match expected ones.";
+ return false;
+ }
+
+ return true;
+}
+
+bool QpackOfflineDecoder::ReadNextExpectedHeaderList(
+ absl::string_view* expected_headers_data,
+ spdy::Http2HeaderBlock* expected_header_list) {
+ while (true) {
+ absl::string_view::size_type endline = expected_headers_data->find('\n');
+
+ // Even last header list must be followed by an empty line.
+ if (endline == absl::string_view::npos) {
+ QUIC_LOG(ERROR) << "Unexpected end of expected header list file.";
+ return false;
+ }
+
+ if (endline == 0) {
+ // Empty line indicates end of header list.
+ *expected_headers_data = expected_headers_data->substr(1);
+ return true;
+ }
+
+ absl::string_view header_field = expected_headers_data->substr(0, endline);
+ std::vector<absl::string_view> pieces = absl::StrSplit(header_field, '\t');
+
+ if (pieces.size() != 2) {
+ QUIC_LOG(ERROR) << "Header key and value must be separated by TAB.";
+ return false;
+ }
+
+ expected_header_list->AppendValueOrAddHeader(pieces[0], pieces[1]);
+
+ *expected_headers_data = expected_headers_data->substr(endline + 1);
+ }
+}
+
+bool QpackOfflineDecoder::CompareHeaderBlocks(
+ spdy::Http2HeaderBlock decoded_header_list,
+ spdy::Http2HeaderBlock expected_header_list) {
+ if (decoded_header_list == expected_header_list) {
+ return true;
+ }
+
+ // The h2o decoder reshuffles the "content-length" header and pseudo-headers,
+ // see
+ // https://github.com/qpackers/qifs/blob/master/encoded/qpack-03/h2o/README.md.
+ // Remove such headers one by one if they match.
+ const char* kContentLength = "content-length";
+ const char* kPseudoHeaderPrefix = ":";
+ for (spdy::Http2HeaderBlock::iterator decoded_it =
+ decoded_header_list.begin();
+ decoded_it != decoded_header_list.end();) {
+ const absl::string_view key = decoded_it->first;
+ if (key != kContentLength && !absl::StartsWith(key, kPseudoHeaderPrefix)) {
+ ++decoded_it;
+ continue;
+ }
+ spdy::Http2HeaderBlock::iterator expected_it =
+ expected_header_list.find(key);
+ if (expected_it == expected_header_list.end() ||
+ decoded_it->second != expected_it->second) {
+ ++decoded_it;
+ continue;
+ }
+ // SpdyHeaderBlock does not support erasing by iterator, only by key.
+ ++decoded_it;
+ expected_header_list.erase(key);
+ // This will invalidate |key|.
+ decoded_header_list.erase(key);
+ }
+
+ return decoded_header_list == expected_header_list;
+}
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/qpack/qpack_offline_decoder.h b/quiche/quic/test_tools/qpack/qpack_offline_decoder.h
new file mode 100644
index 0000000..71cb92a
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_offline_decoder.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_OFFLINE_DECODER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_OFFLINE_DECODER_H_
+
+#include <list>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/qpack/qpack_decoder.h"
+#include "quiche/quic/core/quic_error_codes.h"
+#include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
+#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
+#include "quiche/spdy/core/spdy_header_block.h"
+
+namespace quic {
+
+// A decoder to read encoded data from a file, decode it, and compare to
+// a list of expected header lists read from another file. File format is
+// described at
+// https://github.com/quicwg/base-drafts/wiki/QPACK-Offline-Interop.
+class QpackOfflineDecoder : public QpackDecoder::EncoderStreamErrorDelegate {
+ public:
+ QpackOfflineDecoder();
+ ~QpackOfflineDecoder() override = default;
+
+ // Read encoded header blocks and encoder stream data from |input_filename|
+ // and decode them, read expected header lists from
+ // |expected_headers_filename|, and compare decoded header lists to expected
+ // ones. Returns true if there is an equal number of them and the
+ // corresponding ones match, false otherwise.
+ bool DecodeAndVerifyOfflineData(absl::string_view input_filename,
+ absl::string_view expected_headers_filename);
+
+ // QpackDecoder::EncoderStreamErrorDelegate implementation:
+ void OnEncoderStreamError(QuicErrorCode error_code,
+ absl::string_view error_message) override;
+
+ private:
+ // Data structure to hold TestHeadersHandler and QpackProgressiveDecoder until
+ // decoding of a header header block (and all preceding header blocks) is
+ // complete.
+ struct Decoder {
+ std::unique_ptr<test::TestHeadersHandler> headers_handler;
+ std::unique_ptr<QpackProgressiveDecoder> progressive_decoder;
+ uint64_t stream_id;
+ };
+
+ // Parse decoder parameters from |input_filename| and set up |qpack_decoder_|
+ // accordingly.
+ bool ParseInputFilename(absl::string_view input_filename);
+
+ // Read encoded header blocks and encoder stream data from |input_filename|,
+ // pass them to |qpack_decoder_| for decoding, and add decoded header lists to
+ // |decoded_header_lists_|.
+ bool DecodeHeaderBlocksFromFile(absl::string_view input_filename);
+
+ // Read expected header lists from |expected_headers_filename| and verify
+ // decoded header lists in |decoded_header_lists_| against them.
+ bool VerifyDecodedHeaderLists(absl::string_view expected_headers_filename);
+
+ // Parse next header list from |*expected_headers_data| into
+ // |*expected_header_list|, removing consumed data from the beginning of
+ // |*expected_headers_data|. Returns true on success, false if parsing fails.
+ bool ReadNextExpectedHeaderList(absl::string_view* expected_headers_data,
+ spdy::Http2HeaderBlock* expected_header_list);
+
+ // Compare two header lists. Allow for different orders of certain headers as
+ // described at
+ // https://github.com/qpackers/qifs/blob/master/encoded/qpack-03/h2o/README.md.
+ bool CompareHeaderBlocks(spdy::Http2HeaderBlock decoded_header_list,
+ spdy::Http2HeaderBlock expected_header_list);
+
+ bool encoder_stream_error_detected_;
+ test::NoopQpackStreamSenderDelegate decoder_stream_sender_delegate_;
+ std::unique_ptr<QpackDecoder> qpack_decoder_;
+
+ // Objects necessary for decoding, one list element for each header block.
+ std::list<Decoder> decoders_;
+
+ // Decoded header lists.
+ std::list<spdy::Http2HeaderBlock> decoded_header_lists_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_OFFLINE_DECODER_H_
diff --git a/quiche/quic/test_tools/qpack/qpack_test_utils.cc b/quiche/quic/test_tools/qpack/qpack_test_utils.cc
new file mode 100644
index 0000000..b6f5317
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_test_utils.cc
@@ -0,0 +1,27 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
+
+#include <limits>
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+
+namespace quic {
+namespace test {
+
+FragmentSizeGenerator FragmentModeToFragmentSizeGenerator(
+ FragmentMode fragment_mode) {
+ switch (fragment_mode) {
+ case FragmentMode::kSingleChunk:
+ return []() { return std::numeric_limits<size_t>::max(); };
+ case FragmentMode::kOctetByOctet:
+ return []() { return 1; };
+ }
+ QUIC_BUG(quic_bug_10259_1)
+ << "Unknown FragmentMode " << static_cast<int>(fragment_mode);
+ return []() { return 0; };
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/qpack/qpack_test_utils.h b/quiche/quic/test_tools/qpack/qpack_test_utils.h
new file mode 100644
index 0000000..c6f1c65
--- /dev/null
+++ b/quiche/quic/test_tools/qpack/qpack_test_utils.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_TEST_UTILS_H_
+
+#include <cstddef>
+#include <functional>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/qpack/qpack_stream_sender_delegate.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+// Called repeatedly to determine the size of each fragment when encoding or
+// decoding. Must return a positive value.
+using FragmentSizeGenerator = std::function<size_t()>;
+
+enum class FragmentMode {
+ kSingleChunk,
+ kOctetByOctet,
+};
+
+FragmentSizeGenerator FragmentModeToFragmentSizeGenerator(
+ FragmentMode fragment_mode);
+
+// Mock QpackUnidirectionalStreamSenderDelegate implementation.
+class MockQpackStreamSenderDelegate : public QpackStreamSenderDelegate {
+ public:
+ ~MockQpackStreamSenderDelegate() override = default;
+
+ MOCK_METHOD(void, WriteStreamData, (absl::string_view data), (override));
+ MOCK_METHOD(uint64_t, NumBytesBuffered, (), (const, override));
+};
+
+class NoopQpackStreamSenderDelegate : public QpackStreamSenderDelegate {
+ public:
+ ~NoopQpackStreamSenderDelegate() override = default;
+
+ void WriteStreamData(absl::string_view /*data*/) override {}
+
+ uint64_t NumBytesBuffered() const override { return 0; }
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QPACK_QPACK_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/quic_buffered_packet_store_peer.cc b/quiche/quic/test_tools/quic_buffered_packet_store_peer.cc
new file mode 100644
index 0000000..4d11806
--- /dev/null
+++ b/quiche/quic/test_tools/quic_buffered_packet_store_peer.cc
@@ -0,0 +1,25 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_buffered_packet_store_peer.h"
+
+#include "quiche/quic/core/quic_buffered_packet_store.h"
+
+namespace quic {
+namespace test {
+
+// static
+QuicAlarm* QuicBufferedPacketStorePeer::expiration_alarm(
+ QuicBufferedPacketStore* store) {
+ return store->expiration_alarm_.get();
+}
+
+// static
+void QuicBufferedPacketStorePeer::set_clock(QuicBufferedPacketStore* store,
+ const QuicClock* clock) {
+ store->clock_ = clock;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_buffered_packet_store_peer.h b/quiche/quic/test_tools/quic_buffered_packet_store_peer.h
new file mode 100644
index 0000000..0610274
--- /dev/null
+++ b/quiche/quic/test_tools/quic_buffered_packet_store_peer.h
@@ -0,0 +1,32 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_BUFFERED_PACKET_STORE_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_BUFFERED_PACKET_STORE_PEER_H_
+
+#include <memory>
+
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_clock.h"
+
+namespace quic {
+
+class QuicBufferedPacketStore;
+
+namespace test {
+
+class QuicBufferedPacketStorePeer {
+ public:
+ QuicBufferedPacketStorePeer() = delete;
+
+ static QuicAlarm* expiration_alarm(QuicBufferedPacketStore* store);
+
+ static void set_clock(QuicBufferedPacketStore* store, const QuicClock* clock);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_BUFFERED_PACKET_STORE_PEER_H_
diff --git a/quiche/quic/test_tools/quic_client_peer.cc b/quiche/quic/test_tools/quic_client_peer.cc
new file mode 100644
index 0000000..0b58e22
--- /dev/null
+++ b/quiche/quic/test_tools/quic_client_peer.cc
@@ -0,0 +1,35 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_client_peer.h"
+
+#include "quiche/quic/tools/quic_client.h"
+
+namespace quic {
+namespace test {
+
+// static
+bool QuicClientPeer::CreateUDPSocketAndBind(QuicClient* client) {
+ return client->network_helper()->CreateUDPSocketAndBind(
+ client->server_address(), client->bind_to_address(),
+ client->local_port());
+}
+
+// static
+void QuicClientPeer::CleanUpUDPSocket(QuicClient* client, int fd) {
+ client->epoll_network_helper()->CleanUpUDPSocket(fd);
+}
+
+// static
+void QuicClientPeer::SetClientPort(QuicClient* client, int port) {
+ client->epoll_network_helper()->SetClientPort(port);
+}
+
+// static
+void QuicClientPeer::SetWriter(QuicClient* client, QuicPacketWriter* writer) {
+ client->set_writer(writer);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_client_peer.h b/quiche/quic/test_tools/quic_client_peer.h
new file mode 100644
index 0000000..7070779
--- /dev/null
+++ b/quiche/quic/test_tools/quic_client_peer.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PEER_H_
+
+namespace quic {
+
+class QuicClient;
+class QuicPacketWriter;
+
+namespace test {
+
+class QuicClientPeer {
+ public:
+ QuicClientPeer() = delete;
+
+ static bool CreateUDPSocketAndBind(QuicClient* client);
+ static void CleanUpUDPSocket(QuicClient* client, int fd);
+ static void SetClientPort(QuicClient* client, int port);
+ static void SetWriter(QuicClient* client, QuicPacketWriter* writer);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PEER_H_
diff --git a/quiche/quic/test_tools/quic_client_promised_info_peer.cc b/quiche/quic/test_tools/quic_client_promised_info_peer.cc
new file mode 100644
index 0000000..5ea080c
--- /dev/null
+++ b/quiche/quic/test_tools/quic_client_promised_info_peer.cc
@@ -0,0 +1,17 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_client_promised_info_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+QuicAlarm* QuicClientPromisedInfoPeer::GetAlarm(
+ QuicClientPromisedInfo* promised_stream) {
+ return promised_stream->cleanup_alarm_.get();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_client_promised_info_peer.h b/quiche/quic/test_tools/quic_client_promised_info_peer.h
new file mode 100644
index 0000000..596200b
--- /dev/null
+++ b/quiche/quic/test_tools/quic_client_promised_info_peer.h
@@ -0,0 +1,22 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PROMISED_INFO_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PROMISED_INFO_PEER_H_
+
+#include "quiche/quic/core/http/quic_client_promised_info.h"
+
+namespace quic {
+namespace test {
+
+class QuicClientPromisedInfoPeer {
+ public:
+ QuicClientPromisedInfoPeer() = delete;
+
+ static QuicAlarm* GetAlarm(QuicClientPromisedInfo* promised_stream);
+};
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_PROMISED_INFO_PEER_H_
diff --git a/quiche/quic/test_tools/quic_client_session_cache_peer.h b/quiche/quic/test_tools/quic_client_session_cache_peer.h
new file mode 100644
index 0000000..b070ef6
--- /dev/null
+++ b/quiche/quic/test_tools/quic_client_session_cache_peer.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_SESSION_CACHE_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_SESSION_CACHE_PEER_H_
+
+#include "quiche/quic/core/crypto/quic_client_session_cache.h"
+
+namespace quic {
+namespace test {
+
+class QuicClientSessionCachePeer {
+ public:
+ static std::string GetToken(QuicClientSessionCache* cache,
+ const QuicServerId& server_id) {
+ auto iter = cache->cache_.Lookup(server_id);
+ if (iter == cache->cache_.end()) {
+ return {};
+ }
+ return iter->second->token;
+ }
+
+ static bool HasEntry(QuicClientSessionCache* cache,
+ const QuicServerId& server_id) {
+ return cache->cache_.Lookup(server_id) != cache->cache_.end();
+ }
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CLIENT_SESSION_CACHE_PEER_H_
diff --git a/quiche/quic/test_tools/quic_coalesced_packet_peer.cc b/quiche/quic/test_tools/quic_coalesced_packet_peer.cc
new file mode 100644
index 0000000..eeb1621
--- /dev/null
+++ b/quiche/quic/test_tools/quic_coalesced_packet_peer.cc
@@ -0,0 +1,23 @@
+// Copyright (c) 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_coalesced_packet_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicCoalescedPacketPeer::SetMaxPacketLength(
+ QuicCoalescedPacket& coalesced_packet, QuicPacketLength length) {
+ coalesced_packet.max_packet_length_ = length;
+}
+
+// static
+std::string* QuicCoalescedPacketPeer::GetMutableEncryptedBuffer(
+ QuicCoalescedPacket& coalesced_packet, EncryptionLevel encryption_level) {
+ return &coalesced_packet.encrypted_buffers_[encryption_level];
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_coalesced_packet_peer.h b/quiche/quic/test_tools/quic_coalesced_packet_peer.h
new file mode 100644
index 0000000..c84c37c
--- /dev/null
+++ b/quiche/quic/test_tools/quic_coalesced_packet_peer.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_COALESCED_PACKET_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_COALESCED_PACKET_PEER_H_
+
+#include "quiche/quic/core/quic_coalesced_packet.h"
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+namespace test {
+
+class QuicCoalescedPacketPeer {
+ public:
+ static void SetMaxPacketLength(QuicCoalescedPacket& coalesced_packet,
+ QuicPacketLength length);
+
+ static std::string* GetMutableEncryptedBuffer(
+ QuicCoalescedPacket& coalesced_packet, EncryptionLevel encryption_level);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_COALESCED_PACKET_PEER_H_
diff --git a/quiche/quic/test_tools/quic_config_peer.cc b/quiche/quic/test_tools/quic_config_peer.cc
new file mode 100644
index 0000000..9d1b1be
--- /dev/null
+++ b/quiche/quic/test_tools/quic_config_peer.cc
@@ -0,0 +1,143 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_config_peer.h"
+
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection_id.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(
+ QuicConfig* config,
+ uint32_t window_bytes) {
+ config->initial_stream_flow_control_window_bytes_.SetReceivedValue(
+ window_bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes) {
+ config->initial_max_stream_data_bytes_incoming_bidirectional_
+ .SetReceivedValue(window_bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes) {
+ config->initial_max_stream_data_bytes_outgoing_bidirectional_
+ .SetReceivedValue(window_bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes) {
+ config->initial_max_stream_data_bytes_unidirectional_.SetReceivedValue(
+ window_bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
+ QuicConfig* config,
+ uint32_t window_bytes) {
+ config->initial_session_flow_control_window_bytes_.SetReceivedValue(
+ window_bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedConnectionOptions(
+ QuicConfig* config,
+ const QuicTagVector& options) {
+ config->connection_options_.SetReceivedValues(options);
+}
+
+// static
+void QuicConfigPeer::SetReceivedBytesForConnectionId(QuicConfig* config,
+ uint32_t bytes) {
+ QUICHE_DCHECK(bytes == 0 || bytes == 8);
+ config->bytes_for_connection_id_.SetReceivedValue(bytes);
+}
+
+// static
+void QuicConfigPeer::SetReceivedDisableConnectionMigration(QuicConfig* config) {
+ config->connection_migration_disabled_.SetReceivedValue(1);
+}
+
+// static
+void QuicConfigPeer::SetReceivedMaxBidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams) {
+ config->max_bidirectional_streams_.SetReceivedValue(max_streams);
+}
+// static
+void QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams) {
+ config->max_unidirectional_streams_.SetReceivedValue(max_streams);
+}
+
+// static
+void QuicConfigPeer::SetConnectionOptionsToSend(QuicConfig* config,
+ const QuicTagVector& options) {
+ config->SetConnectionOptionsToSend(options);
+}
+
+// static
+void QuicConfigPeer::SetReceivedStatelessResetToken(
+ QuicConfig* config,
+ const StatelessResetToken& token) {
+ config->stateless_reset_token_.SetReceivedValue(token);
+}
+
+// static
+void QuicConfigPeer::SetReceivedMaxPacketSize(QuicConfig* config,
+ uint32_t max_udp_payload_size) {
+ config->max_udp_payload_size_.SetReceivedValue(max_udp_payload_size);
+}
+
+// static
+void QuicConfigPeer::SetReceivedMinAckDelayMs(QuicConfig* config,
+ uint32_t min_ack_delay_ms) {
+ config->min_ack_delay_ms_.SetReceivedValue(min_ack_delay_ms);
+}
+
+// static
+void QuicConfigPeer::SetNegotiated(QuicConfig* config, bool negotiated) {
+ config->negotiated_ = negotiated;
+}
+
+// static
+void QuicConfigPeer::SetReceivedOriginalConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& original_destination_connection_id) {
+ config->received_original_destination_connection_id_ =
+ original_destination_connection_id;
+}
+
+// static
+void QuicConfigPeer::SetReceivedInitialSourceConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& initial_source_connection_id) {
+ config->received_initial_source_connection_id_ = initial_source_connection_id;
+}
+
+// static
+void QuicConfigPeer::SetReceivedRetrySourceConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& retry_source_connection_id) {
+ config->received_retry_source_connection_id_ = retry_source_connection_id;
+}
+
+// static
+void QuicConfigPeer::SetReceivedMaxDatagramFrameSize(
+ QuicConfig* config,
+ uint64_t max_datagram_frame_size) {
+ config->max_datagram_frame_size_.SetReceivedValue(max_datagram_frame_size);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_config_peer.h b/quiche/quic/test_tools/quic_config_peer.h
new file mode 100644
index 0000000..ef106b0
--- /dev/null
+++ b/quiche/quic/test_tools/quic_config_peer.h
@@ -0,0 +1,88 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONFIG_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CONFIG_PEER_H_
+
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+
+class QuicConfig;
+
+namespace test {
+
+class QuicConfigPeer {
+ public:
+ QuicConfigPeer() = delete;
+
+ static void SetReceivedInitialStreamFlowControlWindow(QuicConfig* config,
+ uint32_t window_bytes);
+
+ static void SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes);
+
+ static void SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes);
+
+ static void SetReceivedInitialMaxStreamDataBytesUnidirectional(
+ QuicConfig* config,
+ uint32_t window_bytes);
+
+ static void SetReceivedInitialSessionFlowControlWindow(QuicConfig* config,
+ uint32_t window_bytes);
+
+ static void SetReceivedConnectionOptions(QuicConfig* config,
+ const QuicTagVector& options);
+
+ static void SetReceivedBytesForConnectionId(QuicConfig* config,
+ uint32_t bytes);
+
+ static void SetReceivedDisableConnectionMigration(QuicConfig* config);
+
+ static void SetReceivedMaxBidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams);
+ static void SetReceivedMaxUnidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams);
+
+ static void SetConnectionOptionsToSend(QuicConfig* config,
+ const QuicTagVector& options);
+
+ static void SetReceivedStatelessResetToken(QuicConfig* config,
+ const StatelessResetToken& token);
+
+ static void SetReceivedMaxPacketSize(QuicConfig* config,
+ uint32_t max_udp_payload_size);
+
+ static void SetReceivedMinAckDelayMs(QuicConfig* config,
+ uint32_t min_ack_delay_ms);
+
+ static void SetNegotiated(QuicConfig* config, bool negotiated);
+
+ static void SetReceivedOriginalConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& original_destination_connection_id);
+
+ static void SetReceivedInitialSourceConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& initial_source_connection_id);
+
+ static void SetReceivedRetrySourceConnectionId(
+ QuicConfig* config,
+ const QuicConnectionId& retry_source_connection_id);
+
+ static void SetReceivedMaxDatagramFrameSize(QuicConfig* config,
+ uint64_t max_datagram_frame_size);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CONFIG_PEER_H_
diff --git a/quiche/quic/test_tools/quic_connection_id_manager_peer.h b/quiche/quic/test_tools/quic_connection_id_manager_peer.h
new file mode 100644
index 0000000..e7ac330
--- /dev/null
+++ b/quiche/quic/test_tools/quic_connection_id_manager_peer.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_ID_MANAGER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_ID_MANAGER_PEER_H_
+
+#include "quiche/quic/core/quic_connection_id_manager.h"
+
+namespace quic {
+namespace test {
+
+class QuicConnectionIdManagerPeer {
+ public:
+ static QuicAlarm* GetRetirePeerIssuedConnectionIdAlarm(
+ QuicPeerIssuedConnectionIdManager* manager) {
+ return manager->retire_connection_id_alarm_.get();
+ }
+
+ static QuicAlarm* GetRetireSelfIssuedConnectionIdAlarm(
+ QuicSelfIssuedConnectionIdManager* manager) {
+ return manager->retire_connection_id_alarm_.get();
+ }
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_ID_MANAGER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
new file mode 100644
index 0000000..73ec27c
--- /dev/null
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -0,0 +1,550 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
+#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_received_packet_manager.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/quic/test_tools/quic_connection_id_manager_peer.h"
+#include "quiche/quic/test_tools/quic_framer_peer.h"
+#include "quiche/quic/test_tools/quic_sent_packet_manager_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicConnectionPeer::SetSendAlgorithm(
+ QuicConnection* connection,
+ SendAlgorithmInterface* send_algorithm) {
+ GetSentPacketManager(connection)->SetSendAlgorithm(send_algorithm);
+}
+
+// static
+void QuicConnectionPeer::SetLossAlgorithm(
+ QuicConnection* connection,
+ LossDetectionInterface* loss_algorithm) {
+ GetSentPacketManager(connection)->loss_algorithm_ = loss_algorithm;
+}
+
+// static
+void QuicConnectionPeer::PopulateStopWaitingFrame(
+ QuicConnection* connection,
+ QuicStopWaitingFrame* stop_waiting) {
+ connection->PopulateStopWaitingFrame(stop_waiting);
+}
+
+// static
+QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
+ QuicConnection* connection) {
+ return &connection->packet_creator_;
+}
+
+// static
+QuicSentPacketManager* QuicConnectionPeer::GetSentPacketManager(
+ QuicConnection* connection) {
+ return &connection->sent_packet_manager_;
+}
+
+// static
+QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout(
+ QuicConnection* connection) {
+ return connection->idle_network_detector_.idle_network_timeout_;
+}
+
+// static
+QuicTime::Delta QuicConnectionPeer::GetHandshakeTimeout(
+ QuicConnection* connection) {
+ return connection->idle_network_detector_.handshake_timeout_;
+}
+
+// static
+void QuicConnectionPeer::SetPerspective(QuicConnection* connection,
+ Perspective perspective) {
+ connection->perspective_ = perspective;
+ QuicFramerPeer::SetPerspective(&connection->framer_, perspective);
+}
+
+// static
+void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
+ const QuicSocketAddress& self_address) {
+ connection->default_path_.self_address = self_address;
+}
+
+// static
+void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection,
+ const QuicSocketAddress& peer_address) {
+ connection->UpdatePeerAddress(peer_address);
+}
+
+// static
+void QuicConnectionPeer::SetDirectPeerAddress(
+ QuicConnection* connection,
+ const QuicSocketAddress& direct_peer_address) {
+ connection->direct_peer_address_ = direct_peer_address;
+}
+
+// static
+void QuicConnectionPeer::SetEffectivePeerAddress(
+ QuicConnection* connection,
+ const QuicSocketAddress& effective_peer_address) {
+ connection->default_path_.peer_address = effective_peer_address;
+}
+
+// static
+void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
+ QuicFramer* framer) {
+ QuicFramerPeer::SwapCrypters(framer, &connection->framer_);
+}
+
+// static
+void QuicConnectionPeer::SetCurrentPacket(QuicConnection* connection,
+ absl::string_view current_packet) {
+ connection->current_packet_data_ = current_packet.data();
+ connection->last_size_ = current_packet.size();
+}
+
+// static
+QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
+ QuicConnection* connection) {
+ return connection->helper_;
+}
+
+// static
+QuicAlarmFactory* QuicConnectionPeer::GetAlarmFactory(
+ QuicConnection* connection) {
+ return connection->alarm_factory_;
+}
+
+// static
+QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
+ return &connection->framer_;
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
+ return connection->ack_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
+ return connection->ping_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
+ QuicConnection* connection) {
+ return connection->retransmission_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
+ return connection->send_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetMtuDiscoveryAlarm(
+ QuicConnection* connection) {
+ return connection->mtu_discovery_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(
+ QuicConnection* connection) {
+ return connection->process_undecryptable_packets_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(
+ QuicConnection* connection) {
+ return connection->discard_previous_one_rtt_keys_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(
+ QuicConnection* connection) {
+ return connection->discard_zero_rtt_decryption_keys_alarm_.get();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetRetirePeerIssuedConnectionIdAlarm(
+ QuicConnection* connection) {
+ if (connection->peer_issued_cid_manager_ == nullptr) {
+ return nullptr;
+ }
+ return QuicConnectionIdManagerPeer::GetRetirePeerIssuedConnectionIdAlarm(
+ connection->peer_issued_cid_manager_.get());
+}
+// static
+QuicAlarm* QuicConnectionPeer::GetRetireSelfIssuedConnectionIdAlarm(
+ QuicConnection* connection) {
+ if (connection->self_issued_cid_manager_ == nullptr) {
+ return nullptr;
+ }
+ return QuicConnectionIdManagerPeer::GetRetireSelfIssuedConnectionIdAlarm(
+ connection->self_issued_cid_manager_.get());
+}
+
+// static
+QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) {
+ return connection->writer_;
+}
+
+// static
+void QuicConnectionPeer::SetWriter(QuicConnection* connection,
+ QuicPacketWriter* writer,
+ bool owns_writer) {
+ if (connection->owns_writer_) {
+ delete connection->writer_;
+ }
+ connection->writer_ = writer;
+ connection->owns_writer_ = owns_writer;
+}
+
+// static
+void QuicConnectionPeer::TearDownLocalConnectionState(
+ QuicConnection* connection) {
+ connection->connected_ = false;
+}
+
+// static
+QuicEncryptedPacket* QuicConnectionPeer::GetConnectionClosePacket(
+ QuicConnection* connection) {
+ if (connection->termination_packets_ == nullptr ||
+ connection->termination_packets_->empty()) {
+ return nullptr;
+ }
+ return (*connection->termination_packets_)[0].get();
+}
+
+// static
+QuicPacketHeader* QuicConnectionPeer::GetLastHeader(
+ QuicConnection* connection) {
+ return &connection->last_header_;
+}
+
+// static
+QuicConnectionStats* QuicConnectionPeer::GetStats(QuicConnection* connection) {
+ return &connection->stats_;
+}
+
+// static
+QuicPacketCount QuicConnectionPeer::GetPacketsBetweenMtuProbes(
+ QuicConnection* connection) {
+ return connection->mtu_discoverer_.packets_between_probes();
+}
+
+// static
+void QuicConnectionPeer::ReInitializeMtuDiscoverer(
+ QuicConnection* connection,
+ QuicPacketCount packets_between_probes_base,
+ QuicPacketNumber next_probe_at) {
+ connection->mtu_discoverer_ =
+ QuicConnectionMtuDiscoverer(packets_between_probes_base, next_probe_at);
+}
+
+// static
+void QuicConnectionPeer::SetAckDecimationDelay(QuicConnection* connection,
+ float ack_decimation_delay) {
+ for (auto& received_packet_manager :
+ connection->uber_received_packet_manager_.received_packet_managers_) {
+ received_packet_manager.ack_decimation_delay_ = ack_decimation_delay;
+ }
+}
+
+// static
+bool QuicConnectionPeer::HasRetransmittableFrames(QuicConnection* connection,
+ uint64_t packet_number) {
+ return QuicSentPacketManagerPeer::HasRetransmittableFrames(
+ GetSentPacketManager(connection), packet_number);
+}
+
+// static
+bool QuicConnectionPeer::GetNoStopWaitingFrames(QuicConnection* connection) {
+ return connection->no_stop_waiting_frames_;
+}
+
+// static
+void QuicConnectionPeer::SetNoStopWaitingFrames(QuicConnection* connection,
+ bool no_stop_waiting_frames) {
+ connection->no_stop_waiting_frames_ = no_stop_waiting_frames;
+}
+
+// static
+void QuicConnectionPeer::SetMaxTrackedPackets(
+ QuicConnection* connection,
+ QuicPacketCount max_tracked_packets) {
+ connection->max_tracked_packets_ = max_tracked_packets;
+}
+
+// static
+void QuicConnectionPeer::SetNegotiatedVersion(QuicConnection* connection) {
+ connection->version_negotiated_ = true;
+ if (connection->perspective() == Perspective::IS_SERVER &&
+ !QuicFramerPeer::infer_packet_header_type_from_version(
+ &connection->framer_)) {
+ connection->framer_.InferPacketHeaderTypeFromVersion();
+ }
+}
+
+// static
+void QuicConnectionPeer::SetMaxConsecutiveNumPacketsWithNoRetransmittableFrames(
+ QuicConnection* connection,
+ size_t new_value) {
+ connection->max_consecutive_num_packets_with_no_retransmittable_frames_ =
+ new_value;
+}
+
+// static
+bool QuicConnectionPeer::SupportsReleaseTime(QuicConnection* connection) {
+ return connection->supports_release_time_;
+}
+
+// static
+QuicConnection::PacketContent QuicConnectionPeer::GetCurrentPacketContent(
+ QuicConnection* connection) {
+ return connection->current_packet_content_;
+}
+
+// static
+void QuicConnectionPeer::SetLastHeaderFormat(QuicConnection* connection,
+ PacketHeaderFormat format) {
+ connection->last_header_.form = format;
+}
+
+// static
+void QuicConnectionPeer::AddBytesReceived(QuicConnection* connection,
+ size_t length) {
+ if (connection->EnforceAntiAmplificationLimit()) {
+ connection->default_path_.bytes_received_before_address_validation +=
+ length;
+ }
+}
+
+// static
+void QuicConnectionPeer::SetAddressValidated(QuicConnection* connection) {
+ connection->default_path_.validated = true;
+}
+
+// static
+void QuicConnectionPeer::SendConnectionClosePacket(
+ QuicConnection* connection,
+ QuicIetfTransportErrorCodes ietf_error,
+ QuicErrorCode error,
+ const std::string& details) {
+ connection->SendConnectionClosePacket(error, ietf_error, details);
+}
+
+// static
+size_t QuicConnectionPeer::GetNumEncryptionLevels(QuicConnection* connection) {
+ size_t count = 0;
+ for (EncryptionLevel level :
+ {ENCRYPTION_INITIAL, ENCRYPTION_HANDSHAKE, ENCRYPTION_ZERO_RTT,
+ ENCRYPTION_FORWARD_SECURE}) {
+ if (connection->framer_.HasEncrypterOfEncryptionLevel(level)) {
+ ++count;
+ }
+ }
+ return count;
+}
+
+// static
+QuicNetworkBlackholeDetector& QuicConnectionPeer::GetBlackholeDetector(
+ QuicConnection* connection) {
+ return connection->blackhole_detector_;
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetBlackholeDetectorAlarm(
+ QuicConnection* connection) {
+ return connection->blackhole_detector_.alarm_.get();
+}
+
+// static
+QuicTime QuicConnectionPeer::GetPathDegradingDeadline(
+ QuicConnection* connection) {
+ return connection->blackhole_detector_.path_degrading_deadline_;
+}
+
+// static
+QuicTime QuicConnectionPeer::GetBlackholeDetectionDeadline(
+ QuicConnection* connection) {
+ return connection->blackhole_detector_.blackhole_deadline_;
+}
+
+// static
+QuicTime QuicConnectionPeer::GetPathMtuReductionDetectionDeadline(
+ QuicConnection* connection) {
+ return connection->blackhole_detector_.path_mtu_reduction_deadline_;
+}
+
+// static
+QuicTime QuicConnectionPeer::GetIdleNetworkDeadline(
+ QuicConnection* connection) {
+ return connection->idle_network_detector_.GetIdleNetworkDeadline();
+}
+
+// static
+QuicAlarm* QuicConnectionPeer::GetIdleNetworkDetectorAlarm(
+ QuicConnection* connection) {
+ return connection->idle_network_detector_.alarm_.get();
+}
+
+// static
+QuicIdleNetworkDetector& QuicConnectionPeer::GetIdleNetworkDetector(
+ QuicConnection* connection) {
+ return connection->idle_network_detector_;
+}
+
+// static
+void QuicConnectionPeer::SetServerConnectionId(
+ QuicConnection* connection,
+ const QuicConnectionId& server_connection_id) {
+ connection->default_path_.server_connection_id = server_connection_id;
+ connection->InstallInitialCrypters(server_connection_id);
+}
+
+// static
+size_t QuicConnectionPeer::NumUndecryptablePackets(QuicConnection* connection) {
+ return connection->undecryptable_packets_.size();
+}
+
+void QuicConnectionPeer::SetConnectionClose(QuicConnection* connection) {
+ connection->connected_ = false;
+}
+
+// static
+void QuicConnectionPeer::SendPing(QuicConnection* connection) {
+ connection->SendPingAtLevel(connection->encryption_level());
+}
+
+// static
+void QuicConnectionPeer::SetLastPacketDestinationAddress(
+ QuicConnection* connection,
+ const QuicSocketAddress& address) {
+ connection->last_received_packet_info_.destination_address = address;
+}
+
+// static
+QuicPathValidator* QuicConnectionPeer::path_validator(
+ QuicConnection* connection) {
+ return &connection->path_validator_;
+}
+
+// static
+QuicByteCount QuicConnectionPeer::BytesSentOnAlternativePath(
+ QuicConnection* connection) {
+ return connection->alternative_path_.bytes_sent_before_address_validation;
+}
+
+// static
+QuicByteCount QuicConnectionPeer::BytesReceivedOnAlternativePath(
+ QuicConnection* connection) {
+ return connection->alternative_path_.bytes_received_before_address_validation;
+}
+
+// static
+QuicConnectionId QuicConnectionPeer::GetClientConnectionIdOnAlternativePath(
+ const QuicConnection* connection) {
+ return connection->alternative_path_.client_connection_id;
+}
+
+// static
+QuicConnectionId QuicConnectionPeer::GetServerConnectionIdOnAlternativePath(
+ const QuicConnection* connection) {
+ return connection->alternative_path_.server_connection_id;
+}
+
+// static
+bool QuicConnectionPeer::IsAlternativePathValidated(
+ QuicConnection* connection) {
+ return connection->alternative_path_.validated;
+}
+
+// static
+bool QuicConnectionPeer::IsAlternativePath(
+ QuicConnection* connection,
+ const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address) {
+ return connection->IsAlternativePath(self_address, peer_address);
+}
+
+// static
+QuicByteCount QuicConnectionPeer::BytesReceivedBeforeAddressValidation(
+ QuicConnection* connection) {
+ return connection->default_path_.bytes_received_before_address_validation;
+}
+
+// static
+void QuicConnectionPeer::ResetPeerIssuedConnectionIdManager(
+ QuicConnection* connection) {
+ connection->peer_issued_cid_manager_ = nullptr;
+}
+
+// static
+QuicConnection::PathState* QuicConnectionPeer::GetDefaultPath(
+ QuicConnection* connection) {
+ return &connection->default_path_;
+}
+
+// static
+QuicConnection::PathState* QuicConnectionPeer::GetAlternativePath(
+ QuicConnection* connection) {
+ return &connection->alternative_path_;
+}
+
+// static
+void QuicConnectionPeer::RetirePeerIssuedConnectionIdsNoLongerOnPath(
+ QuicConnection* connection) {
+ connection->RetirePeerIssuedConnectionIdsNoLongerOnPath();
+}
+
+// static
+bool QuicConnectionPeer::HasUnusedPeerIssuedConnectionId(
+ const QuicConnection* connection) {
+ return connection->peer_issued_cid_manager_->HasUnusedConnectionId();
+}
+
+// static
+bool QuicConnectionPeer::HasSelfIssuedConnectionIdToConsume(
+ const QuicConnection* connection) {
+ return connection->self_issued_cid_manager_->HasConnectionIdToConsume();
+}
+
+// static
+QuicSelfIssuedConnectionIdManager*
+QuicConnectionPeer::GetSelfIssuedConnectionIdManager(
+ QuicConnection* connection) {
+ return connection->self_issued_cid_manager_.get();
+}
+
+// static
+std::unique_ptr<QuicSelfIssuedConnectionIdManager>
+QuicConnectionPeer::MakeSelfIssuedConnectionIdManager(
+ QuicConnection* connection) {
+ return connection->MakeSelfIssuedConnectionIdManager();
+}
+
+// static
+void QuicConnectionPeer::SetLastDecryptedLevel(QuicConnection* connection,
+ EncryptionLevel level) {
+ connection->last_decrypted_packet_level_ = level;
+}
+
+// static
+QuicCoalescedPacket& QuicConnectionPeer::GetCoalescedPacket(
+ QuicConnection* connection) {
+ return connection->coalesced_packet_;
+}
+
+// static
+void QuicConnectionPeer::FlushCoalescedPacket(QuicConnection* connection) {
+ connection->FlushCoalescedPacket();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
new file mode 100644
index 0000000..b9ca8a3
--- /dev/null
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -0,0 +1,233 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
+
+#include <cstddef>
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_connection_stats.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+
+namespace quic {
+
+struct QuicPacketHeader;
+class QuicAlarm;
+class QuicConnectionHelperInterface;
+class QuicConnectionVisitorInterface;
+class QuicEncryptedPacket;
+class QuicFramer;
+class QuicPacketCreator;
+class QuicPacketWriter;
+class QuicSentPacketManager;
+class SendAlgorithmInterface;
+
+namespace test {
+
+// Peer to make public a number of otherwise private QuicConnection methods.
+class QuicConnectionPeer {
+ public:
+ QuicConnectionPeer() = delete;
+
+ static void SetSendAlgorithm(QuicConnection* connection,
+ SendAlgorithmInterface* send_algorithm);
+
+ static void SetLossAlgorithm(QuicConnection* connection,
+ LossDetectionInterface* loss_algorithm);
+
+ static void PopulateStopWaitingFrame(QuicConnection* connection,
+ QuicStopWaitingFrame* stop_waiting);
+
+ static QuicPacketCreator* GetPacketCreator(QuicConnection* connection);
+
+ static QuicSentPacketManager* GetSentPacketManager(
+ QuicConnection* connection);
+
+ static QuicTime::Delta GetNetworkTimeout(QuicConnection* connection);
+
+ static QuicTime::Delta GetHandshakeTimeout(QuicConnection* connection);
+
+ static void SetPerspective(QuicConnection* connection,
+ Perspective perspective);
+
+ static void SetSelfAddress(QuicConnection* connection,
+ const QuicSocketAddress& self_address);
+
+ static void SetPeerAddress(QuicConnection* connection,
+ const QuicSocketAddress& peer_address);
+
+ static void SetDirectPeerAddress(
+ QuicConnection* connection,
+ const QuicSocketAddress& direct_peer_address);
+
+ static void SetEffectivePeerAddress(
+ QuicConnection* connection,
+ const QuicSocketAddress& effective_peer_address);
+
+ static void SwapCrypters(QuicConnection* connection, QuicFramer* framer);
+
+ static void SetCurrentPacket(QuicConnection* connection,
+ absl::string_view current_packet);
+
+ static QuicConnectionHelperInterface* GetHelper(QuicConnection* connection);
+
+ static QuicAlarmFactory* GetAlarmFactory(QuicConnection* connection);
+
+ static QuicFramer* GetFramer(QuicConnection* connection);
+
+ static QuicAlarm* GetAckAlarm(QuicConnection* connection);
+ static QuicAlarm* GetPingAlarm(QuicConnection* connection);
+ static QuicAlarm* GetRetransmissionAlarm(QuicConnection* connection);
+ static QuicAlarm* GetSendAlarm(QuicConnection* connection);
+ static QuicAlarm* GetMtuDiscoveryAlarm(QuicConnection* connection);
+ static QuicAlarm* GetProcessUndecryptablePacketsAlarm(
+ QuicConnection* connection);
+ static QuicAlarm* GetDiscardPreviousOneRttKeysAlarm(
+ QuicConnection* connection);
+ static QuicAlarm* GetDiscardZeroRttDecryptionKeysAlarm(
+ QuicConnection* connection);
+ static QuicAlarm* GetRetirePeerIssuedConnectionIdAlarm(
+ QuicConnection* connection);
+ static QuicAlarm* GetRetireSelfIssuedConnectionIdAlarm(
+ QuicConnection* connection);
+
+ static QuicPacketWriter* GetWriter(QuicConnection* connection);
+ // If |owns_writer| is true, takes ownership of |writer|.
+ static void SetWriter(QuicConnection* connection,
+ QuicPacketWriter* writer,
+ bool owns_writer);
+ static void TearDownLocalConnectionState(QuicConnection* connection);
+ static QuicEncryptedPacket* GetConnectionClosePacket(
+ QuicConnection* connection);
+
+ static QuicPacketHeader* GetLastHeader(QuicConnection* connection);
+
+ static QuicConnectionStats* GetStats(QuicConnection* connection);
+
+ static QuicPacketCount GetPacketsBetweenMtuProbes(QuicConnection* connection);
+
+ static void ReInitializeMtuDiscoverer(
+ QuicConnection* connection,
+ QuicPacketCount packets_between_probes_base,
+ QuicPacketNumber next_probe_at);
+ static void SetAckDecimationDelay(QuicConnection* connection,
+ float ack_decimation_delay);
+ static bool HasRetransmittableFrames(QuicConnection* connection,
+ uint64_t packet_number);
+ static bool GetNoStopWaitingFrames(QuicConnection* connection);
+ static void SetNoStopWaitingFrames(QuicConnection* connection,
+ bool no_stop_waiting_frames);
+ static void SetMaxTrackedPackets(QuicConnection* connection,
+ QuicPacketCount max_tracked_packets);
+ static void SetNegotiatedVersion(QuicConnection* connection);
+ static void SetMaxConsecutiveNumPacketsWithNoRetransmittableFrames(
+ QuicConnection* connection,
+ size_t new_value);
+ static bool SupportsReleaseTime(QuicConnection* connection);
+ static QuicConnection::PacketContent GetCurrentPacketContent(
+ QuicConnection* connection);
+ static void SetLastHeaderFormat(QuicConnection* connection,
+ PacketHeaderFormat format);
+ static void AddBytesReceived(QuicConnection* connection, size_t length);
+ static void SetAddressValidated(QuicConnection* connection);
+
+ static void SendConnectionClosePacket(QuicConnection* connection,
+ QuicIetfTransportErrorCodes ietf_error,
+ QuicErrorCode error,
+ const std::string& details);
+
+ static size_t GetNumEncryptionLevels(QuicConnection* connection);
+
+ static QuicNetworkBlackholeDetector& GetBlackholeDetector(
+ QuicConnection* connection);
+
+ static QuicAlarm* GetBlackholeDetectorAlarm(QuicConnection* connection);
+
+ static QuicTime GetPathDegradingDeadline(QuicConnection* connection);
+
+ static QuicTime GetBlackholeDetectionDeadline(QuicConnection* connection);
+
+ static QuicTime GetPathMtuReductionDetectionDeadline(
+ QuicConnection* connection);
+
+ static QuicAlarm* GetIdleNetworkDetectorAlarm(QuicConnection* connection);
+
+ static QuicTime GetIdleNetworkDeadline(QuicConnection* connection);
+
+ static QuicIdleNetworkDetector& GetIdleNetworkDetector(
+ QuicConnection* connection);
+
+ static void SetServerConnectionId(
+ QuicConnection* connection,
+ const QuicConnectionId& server_connection_id);
+
+ static size_t NumUndecryptablePackets(QuicConnection* connection);
+
+ static void SetConnectionClose(QuicConnection* connection);
+
+ static void SendPing(QuicConnection* connection);
+
+ static void SetLastPacketDestinationAddress(QuicConnection* connection,
+ const QuicSocketAddress& address);
+
+ static QuicPathValidator* path_validator(QuicConnection* connection);
+
+ static QuicByteCount BytesSentOnAlternativePath(QuicConnection* connection);
+
+ static QuicByteCount BytesReceivedOnAlternativePath(
+ QuicConnection* connection);
+
+ static QuicConnectionId GetClientConnectionIdOnAlternativePath(
+ const QuicConnection* connection);
+
+ static QuicConnectionId GetServerConnectionIdOnAlternativePath(
+ const QuicConnection* connection);
+
+ static bool IsAlternativePath(QuicConnection* connection,
+ const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address);
+
+ static bool IsAlternativePathValidated(QuicConnection* connection);
+
+ static QuicByteCount BytesReceivedBeforeAddressValidation(
+ QuicConnection* connection);
+
+ static void ResetPeerIssuedConnectionIdManager(QuicConnection* connection);
+
+ static QuicConnection::PathState* GetDefaultPath(QuicConnection* connection);
+
+ static QuicConnection::PathState* GetAlternativePath(
+ QuicConnection* connection);
+
+ static void RetirePeerIssuedConnectionIdsNoLongerOnPath(
+ QuicConnection* connection);
+
+ static bool HasUnusedPeerIssuedConnectionId(const QuicConnection* connection);
+
+ static bool HasSelfIssuedConnectionIdToConsume(
+ const QuicConnection* connection);
+
+ static QuicSelfIssuedConnectionIdManager* GetSelfIssuedConnectionIdManager(
+ QuicConnection* connection);
+
+ static std::unique_ptr<QuicSelfIssuedConnectionIdManager>
+ MakeSelfIssuedConnectionIdManager(QuicConnection* connection);
+
+ static void SetLastDecryptedLevel(QuicConnection* connection,
+ EncryptionLevel level);
+
+ static QuicCoalescedPacket& GetCoalescedPacket(QuicConnection* connection);
+
+ static void FlushCoalescedPacket(QuicConnection* connection);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.cc b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
new file mode 100644
index 0000000..f09c0cf
--- /dev/null
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -0,0 +1,160 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_crypto_server_config_peer.h"
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/test_tools/mock_clock.h"
+#include "quiche/quic/test_tools/mock_random.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+QuicCryptoServerConfigPeer::GetPrimaryConfig() {
+ QuicReaderMutexLock locked(&server_config_->configs_lock_);
+ return quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>(
+ server_config_->primary_config_);
+}
+
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+QuicCryptoServerConfigPeer::GetConfig(std::string config_id) {
+ QuicReaderMutexLock locked(&server_config_->configs_lock_);
+ if (config_id == "<primary>") {
+ return quiche::QuicheReferenceCountedPointer<
+ QuicCryptoServerConfig::Config>(server_config_->primary_config_);
+ } else {
+ return server_config_->GetConfigWithScid(config_id);
+ }
+}
+
+ProofSource* QuicCryptoServerConfigPeer::GetProofSource() const {
+ return server_config_->proof_source_.get();
+}
+
+void QuicCryptoServerConfigPeer::ResetProofSource(
+ std::unique_ptr<ProofSource> proof_source) {
+ server_config_->proof_source_ = std::move(proof_source);
+}
+
+std::string QuicCryptoServerConfigPeer::NewSourceAddressToken(
+ std::string config_id,
+ SourceAddressTokens previous_tokens,
+ const QuicIpAddress& ip,
+ QuicRandom* rand,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) {
+ return server_config_->NewSourceAddressToken(
+ *GetConfig(config_id)->source_address_token_boxer, previous_tokens, ip,
+ rand, now, cached_network_params);
+}
+
+HandshakeFailureReason QuicCryptoServerConfigPeer::ValidateSourceAddressTokens(
+ std::string config_id,
+ absl::string_view srct,
+ const QuicIpAddress& ip,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) {
+ SourceAddressTokens tokens;
+ HandshakeFailureReason reason = server_config_->ParseSourceAddressToken(
+ *GetConfig(config_id)->source_address_token_boxer, srct, tokens);
+ if (reason != HANDSHAKE_OK) {
+ return reason;
+ }
+
+ return server_config_->ValidateSourceAddressTokens(tokens, ip, now,
+ cached_network_params);
+}
+
+HandshakeFailureReason
+QuicCryptoServerConfigPeer::ValidateSingleSourceAddressToken(
+ absl::string_view token,
+ const QuicIpAddress& ip,
+ QuicWallTime now) {
+ SourceAddressTokens tokens;
+ HandshakeFailureReason parse_status = server_config_->ParseSourceAddressToken(
+ *GetPrimaryConfig()->source_address_token_boxer, token, tokens);
+ if (HANDSHAKE_OK != parse_status) {
+ return parse_status;
+ }
+ EXPECT_EQ(1, tokens.tokens_size());
+ return server_config_->ValidateSingleSourceAddressToken(tokens.tokens(0), ip,
+ now);
+}
+
+void QuicCryptoServerConfigPeer::CheckConfigs(
+ std::vector<std::pair<std::string, bool>> expected_ids_and_status) {
+ QuicReaderMutexLock locked(&server_config_->configs_lock_);
+
+ ASSERT_EQ(expected_ids_and_status.size(), server_config_->configs_.size())
+ << ConfigsDebug();
+
+ for (const std::pair<const ServerConfigID,
+ quiche::QuicheReferenceCountedPointer<
+ QuicCryptoServerConfig::Config>>& i :
+ server_config_->configs_) {
+ bool found = false;
+ for (std::pair<ServerConfigID, bool>& j : expected_ids_and_status) {
+ if (i.first == j.first && i.second->is_primary == j.second) {
+ found = true;
+ j.first.clear();
+ break;
+ }
+ }
+
+ ASSERT_TRUE(found) << "Failed to find match for " << i.first
+ << " in configs:\n"
+ << ConfigsDebug();
+ }
+}
+
+// ConfigsDebug returns a std::string that contains debugging information about
+// the set of Configs loaded in |server_config_| and their status.
+std::string QuicCryptoServerConfigPeer::ConfigsDebug() {
+ if (server_config_->configs_.empty()) {
+ return "No Configs in QuicCryptoServerConfig";
+ }
+
+ std::string s;
+
+ for (const auto& i : server_config_->configs_) {
+ const quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ config = i.second;
+ if (config->is_primary) {
+ s += "(primary) ";
+ } else {
+ s += " ";
+ }
+ s += config->id;
+ s += "\n";
+ }
+
+ return s;
+}
+
+void QuicCryptoServerConfigPeer::SelectNewPrimaryConfig(int seconds) {
+ QuicWriterMutexLock locked(&server_config_->configs_lock_);
+ server_config_->SelectNewPrimaryConfig(
+ QuicWallTime::FromUNIXSeconds(seconds));
+}
+
+std::string QuicCryptoServerConfigPeer::CompressChain(
+ QuicCompressedCertsCache* compressed_certs_cache,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const std::string& client_cached_cert_hashes) {
+ return QuicCryptoServerConfig::CompressChain(compressed_certs_cache, chain,
+ client_cached_cert_hashes);
+}
+
+uint32_t QuicCryptoServerConfigPeer::source_address_token_future_secs() {
+ return server_config_->source_address_token_future_secs_;
+}
+
+uint32_t QuicCryptoServerConfigPeer::source_address_token_lifetime_secs() {
+ return server_config_->source_address_token_lifetime_secs_;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.h b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
new file mode 100644
index 0000000..463a403
--- /dev/null
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
@@ -0,0 +1,93 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/quic_crypto_server_config.h"
+
+namespace quic {
+namespace test {
+
+// Peer for accessing otherwise private members of a QuicCryptoServerConfig.
+class QuicCryptoServerConfigPeer {
+ public:
+ explicit QuicCryptoServerConfigPeer(QuicCryptoServerConfig* server_config)
+ : server_config_(server_config) {}
+
+ // Returns the primary config.
+ quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ GetPrimaryConfig();
+
+ // Returns the config associated with |config_id|.
+ quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ GetConfig(std::string config_id);
+
+ // Returns a pointer to the ProofSource object.
+ ProofSource* GetProofSource() const;
+
+ // Reset the proof_source_ member.
+ void ResetProofSource(std::unique_ptr<ProofSource> proof_source);
+
+ // Generates a new valid source address token.
+ std::string NewSourceAddressToken(
+ std::string config_id,
+ SourceAddressTokens previous_tokens,
+ const QuicIpAddress& ip,
+ QuicRandom* rand,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params);
+
+ // Attempts to validate the tokens in |srct|.
+ HandshakeFailureReason ValidateSourceAddressTokens(
+ std::string config_id, absl::string_view srct, const QuicIpAddress& ip,
+ QuicWallTime now, CachedNetworkParameters* cached_network_params);
+
+ // Attempts to validate the single source address token in |token|.
+ HandshakeFailureReason ValidateSingleSourceAddressToken(
+ absl::string_view token,
+ const QuicIpAddress& ip,
+ QuicWallTime now);
+
+ // CheckConfigs compares the state of the Configs in |server_config_| to the
+ // description given as arguments.
+ // The first of each pair is the server config ID of a Config. The second is a
+ // boolean describing whether the config is the primary. For example:
+ // CheckConfigs(std::vector<std::pair<ServerConfigID, bool>>()); // checks
+ // that no Configs are loaded.
+ //
+ // // Checks that exactly three Configs are loaded with the given IDs and
+ // // status.
+ // CheckConfigs(
+ // {{"id1", false},
+ // {"id2", true},
+ // {"id3", false}});
+ void CheckConfigs(
+ std::vector<std::pair<ServerConfigID, bool>> expected_ids_and_status);
+
+ // ConfigsDebug returns a std::string that contains debugging information
+ // about the set of Configs loaded in |server_config_| and their status.
+ std::string ConfigsDebug()
+ QUIC_SHARED_LOCKS_REQUIRED(server_config_->configs_lock_);
+
+ void SelectNewPrimaryConfig(int seconds);
+
+ static std::string CompressChain(
+ QuicCompressedCertsCache* compressed_certs_cache,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const std::string& client_cached_cert_hashes);
+
+ uint32_t source_address_token_future_secs();
+
+ uint32_t source_address_token_lifetime_secs();
+
+ private:
+ QuicCryptoServerConfig* server_config_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
diff --git a/quiche/quic/test_tools/quic_dispatcher_peer.cc b/quiche/quic/test_tools/quic_dispatcher_peer.cc
new file mode 100644
index 0000000..e281952
--- /dev/null
+++ b/quiche/quic/test_tools/quic_dispatcher_peer.cc
@@ -0,0 +1,143 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_dispatcher_peer.h"
+
+#include "quiche/quic/core/quic_dispatcher.h"
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+
+namespace quic {
+namespace test {
+
+// static
+QuicTimeWaitListManager* QuicDispatcherPeer::GetTimeWaitListManager(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->time_wait_list_manager_.get();
+}
+
+// static
+void QuicDispatcherPeer::SetTimeWaitListManager(
+ QuicDispatcher* dispatcher,
+ QuicTimeWaitListManager* time_wait_list_manager) {
+ dispatcher->time_wait_list_manager_.reset(time_wait_list_manager);
+}
+
+// static
+void QuicDispatcherPeer::UseWriter(QuicDispatcher* dispatcher,
+ QuicPacketWriterWrapper* writer) {
+ writer->set_writer(dispatcher->writer_.release());
+ dispatcher->writer_.reset(writer);
+}
+
+// static
+QuicPacketWriter* QuicDispatcherPeer::GetWriter(QuicDispatcher* dispatcher) {
+ return dispatcher->writer_.get();
+}
+
+// static
+QuicCompressedCertsCache* QuicDispatcherPeer::GetCache(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->compressed_certs_cache();
+}
+
+// static
+QuicConnectionHelperInterface* QuicDispatcherPeer::GetHelper(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->helper_.get();
+}
+
+// static
+QuicAlarmFactory* QuicDispatcherPeer::GetAlarmFactory(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->alarm_factory_.get();
+}
+
+// static
+QuicDispatcher::WriteBlockedList* QuicDispatcherPeer::GetWriteBlockedList(
+ QuicDispatcher* dispatcher) {
+ return &dispatcher->write_blocked_list_;
+}
+
+// static
+QuicErrorCode QuicDispatcherPeer::GetAndClearLastError(
+ QuicDispatcher* dispatcher) {
+ QuicErrorCode ret = dispatcher->last_error_;
+ dispatcher->last_error_ = QUIC_NO_ERROR;
+ return ret;
+}
+
+// static
+QuicBufferedPacketStore* QuicDispatcherPeer::GetBufferedPackets(
+ QuicDispatcher* dispatcher) {
+ return &(dispatcher->buffered_packets_);
+}
+
+// static
+void QuicDispatcherPeer::set_new_sessions_allowed_per_event_loop(
+ QuicDispatcher* dispatcher,
+ size_t num_session_allowed) {
+ dispatcher->new_sessions_allowed_per_event_loop_ = num_session_allowed;
+}
+
+// static
+void QuicDispatcherPeer::SendPublicReset(
+ QuicDispatcher* dispatcher,
+ const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ QuicConnectionId connection_id,
+ bool ietf_quic,
+ size_t received_packet_length,
+ std::unique_ptr<QuicPerPacketContext> packet_context) {
+ dispatcher->time_wait_list_manager()->SendPublicReset(
+ self_address, peer_address, connection_id, ietf_quic,
+ received_packet_length, std::move(packet_context));
+}
+
+// static
+std::unique_ptr<QuicPerPacketContext> QuicDispatcherPeer::GetPerPacketContext(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->GetPerPacketContext();
+}
+
+// static
+void QuicDispatcherPeer::RestorePerPacketContext(
+ QuicDispatcher* dispatcher,
+ std::unique_ptr<QuicPerPacketContext> context) {
+ dispatcher->RestorePerPacketContext(std::move(context));
+}
+
+// static
+std::string QuicDispatcherPeer::SelectAlpn(
+ QuicDispatcher* dispatcher,
+ const std::vector<std::string>& alpns) {
+ return dispatcher->SelectAlpn(alpns);
+}
+
+// static
+QuicSession* QuicDispatcherPeer::GetFirstSessionIfAny(
+ QuicDispatcher* dispatcher) {
+ if (dispatcher->reference_counted_session_map_.empty()) {
+ return nullptr;
+ }
+ return dispatcher->reference_counted_session_map_.begin()->second.get();
+}
+
+// static
+const QuicSession* QuicDispatcherPeer::FindSession(
+ const QuicDispatcher* dispatcher,
+ QuicConnectionId id) {
+ auto it = dispatcher->reference_counted_session_map_.find(id);
+ return (it == dispatcher->reference_counted_session_map_.end())
+ ? nullptr
+ : it->second.get();
+}
+
+// static
+QuicAlarm* QuicDispatcherPeer::GetClearResetAddressesAlarm(
+ QuicDispatcher* dispatcher) {
+ return dispatcher->clear_stateless_reset_addresses_alarm_.get();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_dispatcher_peer.h b/quiche/quic/test_tools/quic_dispatcher_peer.h
new file mode 100644
index 0000000..57c3c83
--- /dev/null
+++ b/quiche/quic/test_tools/quic_dispatcher_peer.h
@@ -0,0 +1,86 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_DISPATCHER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_DISPATCHER_PEER_H_
+
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_dispatcher.h"
+
+namespace quic {
+
+class QuicPacketWriterWrapper;
+
+namespace test {
+
+class QuicDispatcherPeer {
+ public:
+ QuicDispatcherPeer() = delete;
+
+ static QuicTimeWaitListManager* GetTimeWaitListManager(
+ QuicDispatcher* dispatcher);
+
+ static void SetTimeWaitListManager(
+ QuicDispatcher* dispatcher,
+ QuicTimeWaitListManager* time_wait_list_manager);
+
+ // Injects |writer| into |dispatcher| as the shared writer.
+ static void UseWriter(QuicDispatcher* dispatcher,
+ QuicPacketWriterWrapper* writer);
+
+ static QuicPacketWriter* GetWriter(QuicDispatcher* dispatcher);
+
+ static QuicCompressedCertsCache* GetCache(QuicDispatcher* dispatcher);
+
+ static QuicConnectionHelperInterface* GetHelper(QuicDispatcher* dispatcher);
+
+ static QuicAlarmFactory* GetAlarmFactory(QuicDispatcher* dispatcher);
+
+ static QuicDispatcher::WriteBlockedList* GetWriteBlockedList(
+ QuicDispatcher* dispatcher);
+
+ // Get the dispatcher's record of the last error reported to its framer
+ // visitor's OnError() method. Then set that record to QUIC_NO_ERROR.
+ static QuicErrorCode GetAndClearLastError(QuicDispatcher* dispatcher);
+
+ static QuicBufferedPacketStore* GetBufferedPackets(
+ QuicDispatcher* dispatcher);
+
+ static void set_new_sessions_allowed_per_event_loop(
+ QuicDispatcher* dispatcher,
+ size_t num_session_allowed);
+
+ static void SendPublicReset(
+ QuicDispatcher* dispatcher,
+ const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ QuicConnectionId connection_id,
+ bool ietf_quic,
+ size_t received_packet_length,
+ std::unique_ptr<QuicPerPacketContext> packet_context);
+
+ static std::unique_ptr<QuicPerPacketContext> GetPerPacketContext(
+ QuicDispatcher* dispatcher);
+
+ static void RestorePerPacketContext(QuicDispatcher* dispatcher,
+ std::unique_ptr<QuicPerPacketContext>);
+
+ static std::string SelectAlpn(QuicDispatcher* dispatcher,
+ const std::vector<std::string>& alpns);
+
+ // Get the first session in the session map. Returns nullptr if the map is
+ // empty.
+ static QuicSession* GetFirstSessionIfAny(QuicDispatcher* dispatcher);
+
+ // Find the corresponding session if exsits.
+ static const QuicSession* FindSession(const QuicDispatcher* dispatcher,
+ QuicConnectionId id);
+
+ static QuicAlarm* GetClearResetAddressesAlarm(QuicDispatcher* dispatcher);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_DISPATCHER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_flow_controller_peer.cc b/quiche/quic/test_tools/quic_flow_controller_peer.cc
new file mode 100644
index 0000000..1356082
--- /dev/null
+++ b/quiche/quic/test_tools/quic_flow_controller_peer.cc
@@ -0,0 +1,68 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_flow_controller_peer.h"
+
+#include <list>
+
+#include "quiche/quic/core/quic_flow_controller.h"
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicFlowControllerPeer::SetSendWindowOffset(
+ QuicFlowController* flow_controller,
+ QuicStreamOffset offset) {
+ flow_controller->send_window_offset_ = offset;
+}
+
+// static
+void QuicFlowControllerPeer::SetReceiveWindowOffset(
+ QuicFlowController* flow_controller,
+ QuicStreamOffset offset) {
+ flow_controller->receive_window_offset_ = offset;
+}
+
+// static
+void QuicFlowControllerPeer::SetMaxReceiveWindow(
+ QuicFlowController* flow_controller,
+ QuicByteCount window_size) {
+ flow_controller->receive_window_size_ = window_size;
+}
+
+// static
+QuicStreamOffset QuicFlowControllerPeer::SendWindowOffset(
+ QuicFlowController* flow_controller) {
+ return flow_controller->send_window_offset_;
+}
+
+// static
+QuicByteCount QuicFlowControllerPeer::SendWindowSize(
+ QuicFlowController* flow_controller) {
+ return flow_controller->SendWindowSize();
+}
+
+// static
+QuicStreamOffset QuicFlowControllerPeer::ReceiveWindowOffset(
+ QuicFlowController* flow_controller) {
+ return flow_controller->receive_window_offset_;
+}
+
+// static
+QuicByteCount QuicFlowControllerPeer::ReceiveWindowSize(
+ QuicFlowController* flow_controller) {
+ return flow_controller->receive_window_offset_ -
+ flow_controller->highest_received_byte_offset_;
+}
+
+// static
+QuicByteCount QuicFlowControllerPeer::WindowUpdateThreshold(
+ QuicFlowController* flow_controller) {
+ return flow_controller->WindowUpdateThreshold();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_flow_controller_peer.h b/quiche/quic/test_tools/quic_flow_controller_peer.h
new file mode 100644
index 0000000..7c5e426
--- /dev/null
+++ b/quiche/quic/test_tools/quic_flow_controller_peer.h
@@ -0,0 +1,45 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_FLOW_CONTROLLER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_FLOW_CONTROLLER_PEER_H_
+
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+
+class QuicFlowController;
+
+namespace test {
+
+class QuicFlowControllerPeer {
+ public:
+ QuicFlowControllerPeer() = delete;
+
+ static void SetSendWindowOffset(QuicFlowController* flow_controller,
+ QuicStreamOffset offset);
+
+ static void SetReceiveWindowOffset(QuicFlowController* flow_controller,
+ QuicStreamOffset offset);
+
+ static void SetMaxReceiveWindow(QuicFlowController* flow_controller,
+ QuicByteCount window_size);
+
+ static QuicStreamOffset SendWindowOffset(QuicFlowController* flow_controller);
+
+ static QuicByteCount SendWindowSize(QuicFlowController* flow_controller);
+
+ static QuicStreamOffset ReceiveWindowOffset(
+ QuicFlowController* flow_controller);
+
+ static QuicByteCount ReceiveWindowSize(QuicFlowController* flow_controller);
+
+ static QuicByteCount WindowUpdateThreshold(
+ QuicFlowController* flow_controller);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_FLOW_CONTROLLER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_framer_peer.cc b/quiche/quic/test_tools/quic_framer_peer.cc
new file mode 100644
index 0000000..60ccff8
--- /dev/null
+++ b/quiche/quic/test_tools/quic_framer_peer.cc
@@ -0,0 +1,129 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_framer_peer.h"
+
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+namespace test {
+
+// static
+uint64_t QuicFramerPeer::CalculatePacketNumberFromWire(
+ QuicFramer* framer,
+ QuicPacketNumberLength packet_number_length,
+ QuicPacketNumber last_packet_number,
+ uint64_t packet_number) {
+ return framer->CalculatePacketNumberFromWire(
+ packet_number_length, last_packet_number, packet_number);
+}
+
+// static
+void QuicFramerPeer::SetLastSerializedServerConnectionId(
+ QuicFramer* framer,
+ QuicConnectionId server_connection_id) {
+ framer->last_serialized_server_connection_id_ = server_connection_id;
+}
+
+// static
+void QuicFramerPeer::SetLastSerializedClientConnectionId(
+ QuicFramer* framer,
+ QuicConnectionId client_connection_id) {
+ framer->last_serialized_client_connection_id_ = client_connection_id;
+}
+
+// static
+void QuicFramerPeer::SetLastWrittenPacketNumberLength(
+ QuicFramer* framer,
+ size_t packet_number_length) {
+ framer->last_written_packet_number_length_ = packet_number_length;
+}
+
+// static
+void QuicFramerPeer::SetLargestPacketNumber(QuicFramer* framer,
+ QuicPacketNumber packet_number) {
+ framer->largest_packet_number_ = packet_number;
+}
+
+// static
+void QuicFramerPeer::SetPerspective(QuicFramer* framer,
+ Perspective perspective) {
+ framer->perspective_ = perspective;
+ framer->infer_packet_header_type_from_version_ =
+ perspective == Perspective::IS_CLIENT;
+}
+
+// static
+void QuicFramerPeer::SwapCrypters(QuicFramer* framer1, QuicFramer* framer2) {
+ for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; i++) {
+ framer1->encrypter_[i].swap(framer2->encrypter_[i]);
+ framer1->decrypter_[i].swap(framer2->decrypter_[i]);
+ }
+
+ EncryptionLevel framer2_level = framer2->decrypter_level_;
+ framer2->decrypter_level_ = framer1->decrypter_level_;
+ framer1->decrypter_level_ = framer2_level;
+ framer2_level = framer2->alternative_decrypter_level_;
+ framer2->alternative_decrypter_level_ = framer1->alternative_decrypter_level_;
+ framer1->alternative_decrypter_level_ = framer2_level;
+
+ const bool framer2_latch = framer2->alternative_decrypter_latch_;
+ framer2->alternative_decrypter_latch_ = framer1->alternative_decrypter_latch_;
+ framer1->alternative_decrypter_latch_ = framer2_latch;
+}
+
+// static
+QuicEncrypter* QuicFramerPeer::GetEncrypter(QuicFramer* framer,
+ EncryptionLevel level) {
+ return framer->encrypter_[level].get();
+}
+
+// static
+QuicDecrypter* QuicFramerPeer::GetDecrypter(QuicFramer* framer,
+ EncryptionLevel level) {
+ return framer->decrypter_[level].get();
+}
+
+// static
+void QuicFramerPeer::SetFirstSendingPacketNumber(QuicFramer* framer,
+ uint64_t packet_number) {
+ *const_cast<QuicPacketNumber*>(&framer->first_sending_packet_number_) =
+ QuicPacketNumber(packet_number);
+}
+
+// static
+void QuicFramerPeer::SetExpectedServerConnectionIDLength(
+ QuicFramer* framer,
+ uint8_t expected_server_connection_id_length) {
+ *const_cast<uint8_t*>(&framer->expected_server_connection_id_length_) =
+ expected_server_connection_id_length;
+}
+
+// static
+QuicPacketNumber QuicFramerPeer::GetLargestDecryptedPacketNumber(
+ QuicFramer* framer,
+ PacketNumberSpace packet_number_space) {
+ return framer->largest_decrypted_packet_numbers_[packet_number_space];
+}
+
+// static
+bool QuicFramerPeer::ProcessAndValidateIetfConnectionIdLength(
+ QuicDataReader* reader,
+ ParsedQuicVersion version,
+ Perspective perspective,
+ bool should_update_expected_server_connection_id_length,
+ uint8_t* expected_server_connection_id_length,
+ uint8_t* destination_connection_id_length,
+ uint8_t* source_connection_id_length,
+ std::string* detailed_error) {
+ return QuicFramer::ProcessAndValidateIetfConnectionIdLength(
+ reader, version, perspective,
+ should_update_expected_server_connection_id_length,
+ expected_server_connection_id_length, destination_connection_id_length,
+ source_connection_id_length, detailed_error);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_framer_peer.h b/quiche/quic/test_tools/quic_framer_peer.h
new file mode 100644
index 0000000..3b898d1
--- /dev/null
+++ b/quiche/quic/test_tools/quic_framer_peer.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_FRAMER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_FRAMER_PEER_H_
+
+#include "quiche/quic/core/crypto/quic_encrypter.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+
+namespace test {
+
+class QuicFramerPeer {
+ public:
+ QuicFramerPeer() = delete;
+
+ static uint64_t CalculatePacketNumberFromWire(
+ QuicFramer* framer,
+ QuicPacketNumberLength packet_number_length,
+ QuicPacketNumber last_packet_number,
+ uint64_t packet_number);
+ static void SetLastSerializedServerConnectionId(
+ QuicFramer* framer,
+ QuicConnectionId server_connection_id);
+ static void SetLastSerializedClientConnectionId(
+ QuicFramer* framer,
+ QuicConnectionId client_connection_id);
+ static void SetLastWrittenPacketNumberLength(QuicFramer* framer,
+ size_t packet_number_length);
+ static void SetLargestPacketNumber(QuicFramer* framer,
+ QuicPacketNumber packet_number);
+ static void SetPerspective(QuicFramer* framer, Perspective perspective);
+
+ // SwapCrypters exchanges the state of the crypters of |framer1| with
+ // |framer2|.
+ static void SwapCrypters(QuicFramer* framer1, QuicFramer* framer2);
+
+ static QuicEncrypter* GetEncrypter(QuicFramer* framer, EncryptionLevel level);
+ static QuicDecrypter* GetDecrypter(QuicFramer* framer, EncryptionLevel level);
+
+ static void SetFirstSendingPacketNumber(QuicFramer* framer,
+ uint64_t packet_number);
+ static void SetExpectedServerConnectionIDLength(
+ QuicFramer* framer,
+ uint8_t expected_server_connection_id_length);
+ static QuicPacketNumber GetLargestDecryptedPacketNumber(
+ QuicFramer* framer,
+ PacketNumberSpace packet_number_space);
+
+ static bool ProcessAndValidateIetfConnectionIdLength(
+ QuicDataReader* reader,
+ ParsedQuicVersion version,
+ Perspective perspective,
+ bool should_update_expected_server_connection_id_length,
+ uint8_t* expected_server_connection_id_length,
+ uint8_t* destination_connection_id_length,
+ uint8_t* source_connection_id_length,
+ std::string* detailed_error);
+
+ static void set_current_received_frame_type(
+ QuicFramer* framer,
+ uint64_t current_received_frame_type) {
+ framer->current_received_frame_type_ = current_received_frame_type;
+ }
+
+ static bool infer_packet_header_type_from_version(QuicFramer* framer) {
+ return framer->infer_packet_header_type_from_version_;
+ }
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_FRAMER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_interval_deque_peer.h b/quiche/quic/test_tools/quic_interval_deque_peer.h
new file mode 100644
index 0000000..c522457
--- /dev/null
+++ b/quiche/quic/test_tools/quic_interval_deque_peer.h
@@ -0,0 +1,35 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_INTERVAL_DEQUE_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_INTERVAL_DEQUE_PEER_H_
+
+#include "quiche/quic/core/quic_interval_deque.h"
+
+namespace quic {
+
+namespace test {
+
+class QuicIntervalDequePeer {
+ public:
+ template <class T, class C>
+ static int32_t GetCachedIndex(QuicIntervalDeque<T, C>* interval_deque) {
+ if (!interval_deque->cached_index_.has_value()) {
+ return -1;
+ }
+ return interval_deque->cached_index_.value();
+ }
+
+ template <class T, class C>
+ static T* GetItem(QuicIntervalDeque<T, C>* interval_deque,
+ const std::size_t index) {
+ return &interval_deque->container_[index];
+ }
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_INTERVAL_DEQUE_PEER_H_
diff --git a/quiche/quic/test_tools/quic_mock_syscall_wrapper.cc b/quiche/quic/test_tools/quic_mock_syscall_wrapper.cc
new file mode 100644
index 0000000..f934198
--- /dev/null
+++ b/quiche/quic/test_tools/quic_mock_syscall_wrapper.cc
@@ -0,0 +1,22 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_mock_syscall_wrapper.h"
+
+using testing::_;
+using testing::Invoke;
+
+namespace quic {
+namespace test {
+
+MockQuicSyscallWrapper::MockQuicSyscallWrapper(QuicSyscallWrapper* delegate) {
+ ON_CALL(*this, Sendmsg(_, _, _))
+ .WillByDefault(Invoke(delegate, &QuicSyscallWrapper::Sendmsg));
+
+ ON_CALL(*this, Sendmmsg(_, _, _, _))
+ .WillByDefault(Invoke(delegate, &QuicSyscallWrapper::Sendmmsg));
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_mock_syscall_wrapper.h b/quiche/quic/test_tools/quic_mock_syscall_wrapper.h
new file mode 100644
index 0000000..72a33a8
--- /dev/null
+++ b/quiche/quic/test_tools/quic_mock_syscall_wrapper.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_PLATFORM_IMPL_QUIC_MOCK_SYSCALL_WRAPPER_H_
+#define QUICHE_QUIC_PLATFORM_IMPL_QUIC_MOCK_SYSCALL_WRAPPER_H_
+
+#include "quiche/quic/core/quic_syscall_wrapper.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class MockQuicSyscallWrapper : public QuicSyscallWrapper {
+ public:
+ // Create a standard mock object.
+ MockQuicSyscallWrapper() = default;
+
+ // Create a 'mockable' object that delegates everything to |delegate| by
+ // default.
+ explicit MockQuicSyscallWrapper(QuicSyscallWrapper* delegate);
+
+ MOCK_METHOD(ssize_t,
+ Sendmsg,
+ (int sockfd, const msghdr*, int flags),
+ (override));
+
+ MOCK_METHOD(int,
+ Sendmmsg,
+ (int sockfd, mmsghdr*, unsigned int vlen, int flags),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_IMPL_QUIC_MOCK_SYSCALL_WRAPPER_H_
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.cc b/quiche/quic/test_tools/quic_packet_creator_peer.cc
new file mode 100644
index 0000000..fa62e14
--- /dev/null
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.cc
@@ -0,0 +1,167 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_packet_creator_peer.h"
+
+#include "quiche/quic/core/frames/quic_frame.h"
+#include "quiche/quic/core/quic_packet_creator.h"
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+namespace test {
+
+// static
+bool QuicPacketCreatorPeer::SendVersionInPacket(QuicPacketCreator* creator) {
+ return creator->IncludeVersionInHeader();
+}
+
+// static
+void QuicPacketCreatorPeer::SetSendVersionInPacket(
+ QuicPacketCreator* creator,
+ bool send_version_in_packet) {
+ ParsedQuicVersion version = creator->framer_->version();
+ if (!VersionHasIetfQuicFrames(version.transport_version) &&
+ version.handshake_protocol != PROTOCOL_TLS1_3) {
+ creator->send_version_in_packet_ = send_version_in_packet;
+ return;
+ }
+ if (!send_version_in_packet) {
+ creator->packet_.encryption_level = ENCRYPTION_FORWARD_SECURE;
+ return;
+ }
+ QUICHE_DCHECK(creator->packet_.encryption_level < ENCRYPTION_FORWARD_SECURE);
+}
+
+// static
+void QuicPacketCreatorPeer::SetPacketNumberLength(
+ QuicPacketCreator* creator,
+ QuicPacketNumberLength packet_number_length) {
+ creator->packet_.packet_number_length = packet_number_length;
+}
+
+// static
+QuicPacketNumberLength QuicPacketCreatorPeer::GetPacketNumberLength(
+ QuicPacketCreator* creator) {
+ return creator->GetPacketNumberLength();
+}
+
+// static
+QuicVariableLengthIntegerLength
+QuicPacketCreatorPeer::GetRetryTokenLengthLength(QuicPacketCreator* creator) {
+ return creator->GetRetryTokenLengthLength();
+}
+
+// static
+QuicVariableLengthIntegerLength QuicPacketCreatorPeer::GetLengthLength(
+ QuicPacketCreator* creator) {
+ return creator->GetLengthLength();
+}
+
+void QuicPacketCreatorPeer::SetPacketNumber(QuicPacketCreator* creator,
+ uint64_t s) {
+ QUICHE_DCHECK_NE(0u, s);
+ creator->packet_.packet_number = QuicPacketNumber(s);
+}
+
+void QuicPacketCreatorPeer::SetPacketNumber(QuicPacketCreator* creator,
+ QuicPacketNumber num) {
+ creator->packet_.packet_number = num;
+}
+
+// static
+void QuicPacketCreatorPeer::ClearPacketNumber(QuicPacketCreator* creator) {
+ creator->packet_.packet_number.Clear();
+}
+
+// static
+void QuicPacketCreatorPeer::FillPacketHeader(QuicPacketCreator* creator,
+ QuicPacketHeader* header) {
+ creator->FillPacketHeader(header);
+}
+
+// static
+void QuicPacketCreatorPeer::CreateStreamFrame(QuicPacketCreator* creator,
+ QuicStreamId id,
+ size_t data_length,
+ QuicStreamOffset offset,
+ bool fin,
+ QuicFrame* frame) {
+ creator->CreateStreamFrame(id, data_length, offset, fin, frame);
+}
+
+// static
+bool QuicPacketCreatorPeer::CreateCryptoFrame(QuicPacketCreator* creator,
+ EncryptionLevel level,
+ size_t write_length,
+ QuicStreamOffset offset,
+ QuicFrame* frame) {
+ return creator->CreateCryptoFrame(level, write_length, offset, frame);
+}
+
+// static
+SerializedPacket QuicPacketCreatorPeer::SerializeAllFrames(
+ QuicPacketCreator* creator,
+ const QuicFrames& frames,
+ char* buffer,
+ size_t buffer_len) {
+ QUICHE_DCHECK(creator->queued_frames_.empty());
+ QUICHE_DCHECK(!frames.empty());
+ for (const QuicFrame& frame : frames) {
+ bool success = creator->AddFrame(frame, NOT_RETRANSMISSION);
+ QUICHE_DCHECK(success);
+ }
+ const bool success =
+ creator->SerializePacket(QuicOwnedPacketBuffer(buffer, nullptr),
+ buffer_len, /*allow_padding=*/true);
+ QUICHE_DCHECK(success);
+ SerializedPacket packet = std::move(creator->packet_);
+ // The caller takes ownership of the QuicEncryptedPacket.
+ creator->packet_.encrypted_buffer = nullptr;
+ return packet;
+}
+
+// static
+std::unique_ptr<SerializedPacket>
+QuicPacketCreatorPeer::SerializeConnectivityProbingPacket(
+ QuicPacketCreator* creator) {
+ return creator->SerializeConnectivityProbingPacket();
+}
+
+// static
+std::unique_ptr<SerializedPacket>
+QuicPacketCreatorPeer::SerializePathChallengeConnectivityProbingPacket(
+ QuicPacketCreator* creator,
+ const QuicPathFrameBuffer& payload) {
+ return creator->SerializePathChallengeConnectivityProbingPacket(payload);
+}
+
+// static
+EncryptionLevel QuicPacketCreatorPeer::GetEncryptionLevel(
+ QuicPacketCreator* creator) {
+ return creator->packet_.encryption_level;
+}
+
+// static
+QuicFramer* QuicPacketCreatorPeer::framer(QuicPacketCreator* creator) {
+ return creator->framer_;
+}
+
+// static
+std::string QuicPacketCreatorPeer::GetRetryToken(QuicPacketCreator* creator) {
+ return creator->retry_token_;
+}
+
+// static
+QuicFrames& QuicPacketCreatorPeer::QueuedFrames(QuicPacketCreator* creator) {
+ return creator->queued_frames_;
+}
+
+// static
+void QuicPacketCreatorPeer::SetRandom(QuicPacketCreator* creator,
+ QuicRandom* random) {
+ creator->random_ = random;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.h b/quiche/quic/test_tools/quic_packet_creator_peer.h
new file mode 100644
index 0000000..8af1a30
--- /dev/null
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.h
@@ -0,0 +1,72 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_PACKET_CREATOR_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_PACKET_CREATOR_PEER_H_
+
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+class QuicFramer;
+class QuicPacketCreator;
+class QuicRandom;
+
+namespace test {
+
+class QuicPacketCreatorPeer {
+ public:
+ QuicPacketCreatorPeer() = delete;
+
+ static bool SendVersionInPacket(QuicPacketCreator* creator);
+
+ static void SetSendVersionInPacket(QuicPacketCreator* creator,
+ bool send_version_in_packet);
+ static void SetPacketNumberLength(
+ QuicPacketCreator* creator,
+ QuicPacketNumberLength packet_number_length);
+ static QuicPacketNumberLength GetPacketNumberLength(
+ QuicPacketCreator* creator);
+ static QuicVariableLengthIntegerLength GetRetryTokenLengthLength(
+ QuicPacketCreator* creator);
+ static QuicVariableLengthIntegerLength GetLengthLength(
+ QuicPacketCreator* creator);
+ static void SetPacketNumber(QuicPacketCreator* creator, uint64_t s);
+ static void SetPacketNumber(QuicPacketCreator* creator, QuicPacketNumber num);
+ static void ClearPacketNumber(QuicPacketCreator* creator);
+ static void FillPacketHeader(QuicPacketCreator* creator,
+ QuicPacketHeader* header);
+ static void CreateStreamFrame(QuicPacketCreator* creator,
+ QuicStreamId id,
+ size_t data_length,
+ QuicStreamOffset offset,
+ bool fin,
+ QuicFrame* frame);
+ static bool CreateCryptoFrame(QuicPacketCreator* creator,
+ EncryptionLevel level,
+ size_t write_length,
+ QuicStreamOffset offset,
+ QuicFrame* frame);
+ static SerializedPacket SerializeAllFrames(QuicPacketCreator* creator,
+ const QuicFrames& frames,
+ char* buffer,
+ size_t buffer_len);
+ static std::unique_ptr<SerializedPacket> SerializeConnectivityProbingPacket(
+ QuicPacketCreator* creator);
+ static std::unique_ptr<SerializedPacket>
+ SerializePathChallengeConnectivityProbingPacket(
+ QuicPacketCreator* creator,
+ const QuicPathFrameBuffer& payload);
+
+ static EncryptionLevel GetEncryptionLevel(QuicPacketCreator* creator);
+ static QuicFramer* framer(QuicPacketCreator* creator);
+ static std::string GetRetryToken(QuicPacketCreator* creator);
+ static QuicFrames& QueuedFrames(QuicPacketCreator* creator);
+ static void SetRandom(QuicPacketCreator* creator, QuicRandom* random);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_PACKET_CREATOR_PEER_H_
diff --git a/quiche/quic/test_tools/quic_path_validator_peer.cc b/quiche/quic/test_tools/quic_path_validator_peer.cc
new file mode 100644
index 0000000..42c92cf
--- /dev/null
+++ b/quiche/quic/test_tools/quic_path_validator_peer.cc
@@ -0,0 +1,15 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_path_validator_peer.h"
+
+namespace quic {
+namespace test {
+// static
+QuicAlarm* QuicPathValidatorPeer::retry_timer(QuicPathValidator* validator) {
+ return validator->retry_timer_.get();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_path_validator_peer.h b/quiche/quic/test_tools/quic_path_validator_peer.h
new file mode 100644
index 0000000..0013983
--- /dev/null
+++ b/quiche/quic/test_tools/quic_path_validator_peer.h
@@ -0,0 +1,20 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_PATH_VALIDATOR_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_PATH_VALIDATOR_PEER_H_
+
+#include "quiche/quic/core/quic_path_validator.h"
+
+namespace quic {
+namespace test {
+
+class QuicPathValidatorPeer {
+ public:
+ static QuicAlarm* retry_timer(QuicPathValidator* validator);
+};
+
+} // namespace test
+} // namespace quic
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_PATH_VALIDATOR_PEER_H_
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
new file mode 100644
index 0000000..06588a4
--- /dev/null
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
@@ -0,0 +1,224 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_sent_packet_manager_peer.h"
+
+#include "quiche/quic/core/congestion_control/loss_detection_interface.h"
+#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_sent_packet_manager.h"
+#include "quiche/quic/test_tools/quic_unacked_packet_map_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+size_t QuicSentPacketManagerPeer::GetMaxTailLossProbes(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->max_tail_loss_probes_;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetMaxTailLossProbes(
+ QuicSentPacketManager* sent_packet_manager,
+ size_t max_tail_loss_probes) {
+ sent_packet_manager->max_tail_loss_probes_ = max_tail_loss_probes;
+}
+
+// static
+bool QuicSentPacketManagerPeer::GetUseNewRto(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->use_new_rto_;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetPerspective(
+ QuicSentPacketManager* sent_packet_manager,
+ Perspective perspective) {
+ QuicUnackedPacketMapPeer::SetPerspective(
+ &sent_packet_manager->unacked_packets_, perspective);
+}
+
+// static
+SendAlgorithmInterface* QuicSentPacketManagerPeer::GetSendAlgorithm(
+ const QuicSentPacketManager& sent_packet_manager) {
+ return sent_packet_manager.send_algorithm_.get();
+}
+
+// static
+void QuicSentPacketManagerPeer::SetSendAlgorithm(
+ QuicSentPacketManager* sent_packet_manager,
+ SendAlgorithmInterface* send_algorithm) {
+ sent_packet_manager->SetSendAlgorithm(send_algorithm);
+}
+
+// static
+const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->loss_algorithm_;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetLossAlgorithm(
+ QuicSentPacketManager* sent_packet_manager,
+ LossDetectionInterface* loss_detector) {
+ sent_packet_manager->loss_algorithm_ = loss_detector;
+}
+
+// static
+RttStats* QuicSentPacketManagerPeer::GetRttStats(
+ QuicSentPacketManager* sent_packet_manager) {
+ return &sent_packet_manager->rtt_stats_;
+}
+
+// static
+bool QuicSentPacketManagerPeer::IsRetransmission(
+ QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number) {
+ QUICHE_DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
+ if (!HasRetransmittableFrames(sent_packet_manager, packet_number)) {
+ return false;
+ }
+ return sent_packet_manager->unacked_packets_
+ .GetTransmissionInfo(QuicPacketNumber(packet_number))
+ .transmission_type != NOT_RETRANSMISSION;
+}
+
+// static
+void QuicSentPacketManagerPeer::MarkForRetransmission(
+ QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number,
+ TransmissionType transmission_type) {
+ sent_packet_manager->MarkForRetransmission(QuicPacketNumber(packet_number),
+ transmission_type);
+}
+
+// static
+QuicTime::Delta QuicSentPacketManagerPeer::GetRetransmissionDelay(
+ const QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->GetRetransmissionDelay();
+}
+
+// static
+QuicTime::Delta QuicSentPacketManagerPeer::GetTailLossProbeDelay(
+ const QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->GetTailLossProbeDelay();
+}
+
+// static
+size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
+ const QuicSentPacketManager* sent_packet_manager) {
+ size_t num_unacked_packets = 0;
+ for (auto it = sent_packet_manager->unacked_packets_.begin();
+ it != sent_packet_manager->unacked_packets_.end(); ++it) {
+ if (sent_packet_manager->unacked_packets_.HasRetransmittableFrames(*it)) {
+ ++num_unacked_packets;
+ }
+ }
+ return num_unacked_packets;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetConsecutiveRtoCount(
+ QuicSentPacketManager* sent_packet_manager,
+ size_t count) {
+ sent_packet_manager->consecutive_rto_count_ = count;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetConsecutiveTlpCount(
+ QuicSentPacketManager* sent_packet_manager,
+ size_t count) {
+ sent_packet_manager->consecutive_tlp_count_ = count;
+}
+
+// static
+QuicSustainedBandwidthRecorder& QuicSentPacketManagerPeer::GetBandwidthRecorder(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->sustained_bandwidth_recorder_;
+}
+
+// static
+bool QuicSentPacketManagerPeer::UsingPacing(
+ const QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->using_pacing_;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetUsingPacing(
+ QuicSentPacketManager* sent_packet_manager,
+ bool using_pacing) {
+ sent_packet_manager->using_pacing_ = using_pacing;
+}
+
+// static
+bool QuicSentPacketManagerPeer::HasRetransmittableFrames(
+ QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number) {
+ return sent_packet_manager->unacked_packets_.HasRetransmittableFrames(
+ QuicPacketNumber(packet_number));
+}
+
+// static
+QuicUnackedPacketMap* QuicSentPacketManagerPeer::GetUnackedPacketMap(
+ QuicSentPacketManager* sent_packet_manager) {
+ return &sent_packet_manager->unacked_packets_;
+}
+
+// static
+void QuicSentPacketManagerPeer::DisablePacerBursts(
+ QuicSentPacketManager* sent_packet_manager) {
+ sent_packet_manager->pacing_sender_.burst_tokens_ = 0;
+ sent_packet_manager->pacing_sender_.initial_burst_size_ = 0;
+}
+
+// static
+int QuicSentPacketManagerPeer::GetPacerInitialBurstSize(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->pacing_sender_.initial_burst_size_;
+}
+
+// static
+void QuicSentPacketManagerPeer::SetNextPacedPacketTime(
+ QuicSentPacketManager* sent_packet_manager,
+ QuicTime time) {
+ sent_packet_manager->pacing_sender_.ideal_next_packet_send_time_ = time;
+}
+
+// static
+int QuicSentPacketManagerPeer::GetReorderingShift(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
+ .reordering_shift();
+}
+
+// static
+bool QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
+ .use_adaptive_reordering_threshold();
+}
+
+// static
+bool QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
+ .use_adaptive_time_threshold();
+}
+
+// static
+bool QuicSentPacketManagerPeer::UsePacketThresholdForRuntPackets(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
+ .use_packet_threshold_for_runt_packets();
+}
+
+// static
+int QuicSentPacketManagerPeer::GetNumPtosForPathDegrading(
+ QuicSentPacketManager* sent_packet_manager) {
+ return sent_packet_manager->num_ptos_for_path_degrading_;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.h b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
new file mode 100644
index 0000000..6e32b6b
--- /dev/null
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
@@ -0,0 +1,110 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SENT_PACKET_MANAGER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SENT_PACKET_MANAGER_PEER_H_
+
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_sent_packet_manager.h"
+
+namespace quic {
+
+class SendAlgorithmInterface;
+
+namespace test {
+
+class QuicSentPacketManagerPeer {
+ public:
+ QuicSentPacketManagerPeer() = delete;
+
+ static size_t GetMaxTailLossProbes(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static void SetMaxTailLossProbes(QuicSentPacketManager* sent_packet_manager,
+ size_t max_tail_loss_probes);
+
+ static bool GetUseNewRto(QuicSentPacketManager* sent_packet_manager);
+
+ static void SetPerspective(QuicSentPacketManager* sent_packet_manager,
+ Perspective perspective);
+
+ static SendAlgorithmInterface* GetSendAlgorithm(
+ const QuicSentPacketManager& sent_packet_manager);
+
+ static void SetSendAlgorithm(QuicSentPacketManager* sent_packet_manager,
+ SendAlgorithmInterface* send_algorithm);
+
+ static const LossDetectionInterface* GetLossAlgorithm(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static void SetLossAlgorithm(QuicSentPacketManager* sent_packet_manager,
+ LossDetectionInterface* loss_detector);
+
+ static RttStats* GetRttStats(QuicSentPacketManager* sent_packet_manager);
+
+ // Returns true if |packet_number| is a retransmission of a packet.
+ static bool IsRetransmission(QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number);
+
+ static void MarkForRetransmission(QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number,
+ TransmissionType transmission_type);
+
+ static QuicTime::Delta GetRetransmissionDelay(
+ const QuicSentPacketManager* sent_packet_manager);
+ static QuicTime::Delta GetTailLossProbeDelay(
+ const QuicSentPacketManager* sent_packet_manager);
+
+ static size_t GetNumRetransmittablePackets(
+ const QuicSentPacketManager* sent_packet_manager);
+
+ static void SetConsecutiveRtoCount(QuicSentPacketManager* sent_packet_manager,
+ size_t count);
+
+ static void SetConsecutiveTlpCount(QuicSentPacketManager* sent_packet_manager,
+ size_t count);
+
+ static QuicSustainedBandwidthRecorder& GetBandwidthRecorder(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static void SetUsingPacing(QuicSentPacketManager* sent_packet_manager,
+ bool using_pacing);
+
+ static bool UsingPacing(const QuicSentPacketManager* sent_packet_manager);
+
+ static bool HasRetransmittableFrames(
+ QuicSentPacketManager* sent_packet_manager,
+ uint64_t packet_number);
+
+ static QuicUnackedPacketMap* GetUnackedPacketMap(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static void DisablePacerBursts(QuicSentPacketManager* sent_packet_manager);
+
+ static int GetPacerInitialBurstSize(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static void SetNextPacedPacketTime(QuicSentPacketManager* sent_packet_manager,
+ QuicTime time);
+
+ static int GetReorderingShift(QuicSentPacketManager* sent_packet_manager);
+
+ static bool AdaptiveReorderingThresholdEnabled(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static bool AdaptiveTimeThresholdEnabled(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static bool UsePacketThresholdForRuntPackets(
+ QuicSentPacketManager* sent_packet_manager);
+
+ static int GetNumPtosForPathDegrading(
+ QuicSentPacketManager* sent_packet_manager);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SENT_PACKET_MANAGER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_server_peer.cc b/quiche/quic/test_tools/quic_server_peer.cc
new file mode 100644
index 0000000..6f6c8f9
--- /dev/null
+++ b/quiche/quic/test_tools/quic_server_peer.cc
@@ -0,0 +1,32 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_server_peer.h"
+
+#include "quiche/quic/core/quic_dispatcher.h"
+#include "quiche/quic/core/quic_packet_reader.h"
+#include "quiche/quic/tools/quic_server.h"
+
+namespace quic {
+namespace test {
+
+// static
+bool QuicServerPeer::SetSmallSocket(QuicServer* server) {
+ int size = 1024 * 10;
+ return setsockopt(server->fd_, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)) !=
+ -1;
+}
+
+// static
+QuicDispatcher* QuicServerPeer::GetDispatcher(QuicServer* server) {
+ return server->dispatcher_.get();
+}
+
+// static
+void QuicServerPeer::SetReader(QuicServer* server, QuicPacketReader* reader) {
+ server->packet_reader_.reset(reader);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_server_peer.h b/quiche/quic/test_tools/quic_server_peer.h
new file mode 100644
index 0000000..29a36d4
--- /dev/null
+++ b/quiche/quic/test_tools/quic_server_peer.h
@@ -0,0 +1,28 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_PEER_H_
+
+namespace quic {
+
+class QuicDispatcher;
+class QuicServer;
+class QuicPacketReader;
+
+namespace test {
+
+class QuicServerPeer {
+ public:
+ QuicServerPeer() = delete;
+
+ static bool SetSmallSocket(QuicServer* server);
+ static QuicDispatcher* GetDispatcher(QuicServer* server);
+ static void SetReader(QuicServer* server, QuicPacketReader* reader);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_server_session_base_peer.h b/quiche/quic/test_tools/quic_server_session_base_peer.h
new file mode 100644
index 0000000..5a2bd2d
--- /dev/null
+++ b/quiche/quic/test_tools/quic_server_session_base_peer.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_SESSION_BASE_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_SESSION_BASE_PEER_H_
+
+#include "quiche/quic/core/http/quic_server_session_base.h"
+
+#include "quiche/quic/core/quic_utils.h"
+
+namespace quic {
+namespace test {
+
+class QuicServerSessionBasePeer {
+ public:
+ static QuicStream* GetOrCreateStream(QuicServerSessionBase* s,
+ QuicStreamId id) {
+ return s->GetOrCreateStream(id);
+ }
+ static void SetCryptoStream(QuicServerSessionBase* s,
+ QuicCryptoServerStreamBase* crypto_stream) {
+ s->crypto_stream_.reset(crypto_stream);
+ }
+ static bool IsBandwidthResumptionEnabled(QuicServerSessionBase* s) {
+ return s->bandwidth_resumption_enabled_;
+ }
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_SESSION_BASE_PEER_H_
diff --git a/quiche/quic/test_tools/quic_session_peer.cc b/quiche/quic/test_tools/quic_session_peer.cc
new file mode 100644
index 0000000..bb03bd2
--- /dev/null
+++ b/quiche/quic/test_tools/quic_session_peer.cc
@@ -0,0 +1,250 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_session_peer.h"
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_stream.h"
+#include "quiche/quic/core/quic_utils.h"
+
+namespace quic {
+namespace test {
+
+// static
+QuicStreamId QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(
+ QuicSession* session) {
+ return session->GetNextOutgoingBidirectionalStreamId();
+}
+
+// static
+QuicStreamId QuicSessionPeer::GetNextOutgoingUnidirectionalStreamId(
+ QuicSession* session) {
+ return session->GetNextOutgoingUnidirectionalStreamId();
+}
+
+// static
+void QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(QuicSession* session,
+ QuicStreamId id) {
+ if (VersionHasIetfQuicFrames(session->transport_version())) {
+ session->ietf_streamid_manager_.bidirectional_stream_id_manager_
+ .next_outgoing_stream_id_ = id;
+ return;
+ }
+ session->stream_id_manager_.next_outgoing_stream_id_ = id;
+}
+
+// static
+void QuicSessionPeer::SetMaxOpenIncomingStreams(QuicSession* session,
+ uint32_t max_streams) {
+ if (VersionHasIetfQuicFrames(session->transport_version())) {
+ QUIC_BUG(quic_bug_10193_1)
+ << "SetmaxOpenIncomingStreams deprecated for IETF QUIC";
+ session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
+ max_streams);
+ session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
+ max_streams);
+ return;
+ }
+ session->stream_id_manager_.set_max_open_incoming_streams(max_streams);
+}
+
+// static
+void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
+ QuicSession* session,
+ uint32_t max_streams) {
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+ << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
+ "QUIC";
+ session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
+ max_streams);
+}
+// static
+void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
+ QuicSession* session,
+ uint32_t max_streams) {
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+ << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
+ "QUIC";
+ session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
+ max_streams);
+}
+
+// static
+void QuicSessionPeer::SetMaxOpenOutgoingStreams(QuicSession* session,
+ uint32_t max_streams) {
+ if (VersionHasIetfQuicFrames(session->transport_version())) {
+ QUIC_BUG(quic_bug_10193_2)
+ << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC";
+ return;
+ }
+ session->stream_id_manager_.set_max_open_outgoing_streams(max_streams);
+}
+
+// static
+void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
+ QuicSession* session,
+ uint32_t max_streams) {
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+ << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
+ "QUIC";
+ session->ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+ max_streams);
+}
+// static
+void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
+ QuicSession* session,
+ uint32_t max_streams) {
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+ << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
+ "QUIC";
+ session->ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+ max_streams);
+}
+
+// static
+QuicCryptoStream* QuicSessionPeer::GetMutableCryptoStream(
+ QuicSession* session) {
+ return session->GetMutableCryptoStream();
+}
+
+// static
+QuicWriteBlockedList* QuicSessionPeer::GetWriteBlockedStreams(
+ QuicSession* session) {
+ return &session->write_blocked_streams_;
+}
+
+// static
+QuicStream* QuicSessionPeer::GetOrCreateStream(QuicSession* session,
+ QuicStreamId stream_id) {
+ return session->GetOrCreateStream(stream_id);
+}
+
+// static
+absl::flat_hash_map<QuicStreamId, QuicStreamOffset>&
+QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(QuicSession* session) {
+ return session->locally_closed_streams_highest_offset_;
+}
+
+// static
+QuicSession::StreamMap& QuicSessionPeer::stream_map(QuicSession* session) {
+ return session->stream_map_;
+}
+
+// static
+const QuicSession::ClosedStreams& QuicSessionPeer::closed_streams(
+ QuicSession* session) {
+ return *session->closed_streams();
+}
+
+// static
+void QuicSessionPeer::ActivateStream(QuicSession* session,
+ std::unique_ptr<QuicStream> stream) {
+ return session->ActivateStream(std::move(stream));
+}
+
+// static
+bool QuicSessionPeer::IsStreamClosed(QuicSession* session, QuicStreamId id) {
+ return session->IsClosedStream(id);
+}
+
+// static
+bool QuicSessionPeer::IsStreamCreated(QuicSession* session, QuicStreamId id) {
+ return session->stream_map_.contains(id);
+}
+
+// static
+bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
+ if (VersionHasIetfQuicFrames(session->transport_version())) {
+ if (id % QuicUtils::StreamIdDelta(session->transport_version()) < 2) {
+ return session->ietf_streamid_manager_.bidirectional_stream_id_manager_
+ .available_streams_.contains(id);
+ }
+ return session->ietf_streamid_manager_.unidirectional_stream_id_manager_
+ .available_streams_.contains(id);
+ }
+ return session->stream_id_manager_.available_streams_.contains(id);
+}
+
+// static
+QuicStream* QuicSessionPeer::GetStream(QuicSession* session, QuicStreamId id) {
+ return session->GetStream(id);
+}
+
+// static
+bool QuicSessionPeer::IsStreamWriteBlocked(QuicSession* session,
+ QuicStreamId id) {
+ return session->write_blocked_streams_.IsStreamBlocked(id);
+}
+
+// static
+QuicAlarm* QuicSessionPeer::GetCleanUpClosedStreamsAlarm(QuicSession* session) {
+ return session->closed_streams_clean_up_alarm_.get();
+}
+
+// static
+LegacyQuicStreamIdManager* QuicSessionPeer::GetStreamIdManager(
+ QuicSession* session) {
+ return &session->stream_id_manager_;
+}
+
+// static
+UberQuicStreamIdManager* QuicSessionPeer::ietf_streamid_manager(
+ QuicSession* session) {
+ return &session->ietf_streamid_manager_;
+}
+
+// static
+QuicStreamIdManager* QuicSessionPeer::ietf_bidirectional_stream_id_manager(
+ QuicSession* session) {
+ return &session->ietf_streamid_manager_.bidirectional_stream_id_manager_;
+}
+
+// static
+QuicStreamIdManager* QuicSessionPeer::ietf_unidirectional_stream_id_manager(
+ QuicSession* session) {
+ return &session->ietf_streamid_manager_.unidirectional_stream_id_manager_;
+}
+
+// static
+PendingStream* QuicSessionPeer::GetPendingStream(QuicSession* session,
+ QuicStreamId stream_id) {
+ auto it = session->pending_stream_map_.find(stream_id);
+ return it == session->pending_stream_map_.end() ? nullptr : it->second.get();
+}
+
+// static
+void QuicSessionPeer::set_is_configured(QuicSession* session, bool value) {
+ session->is_configured_ = value;
+}
+
+// static
+void QuicSessionPeer::SetPerspective(QuicSession* session,
+ Perspective perspective) {
+ session->perspective_ = perspective;
+}
+
+// static
+size_t QuicSessionPeer::GetNumOpenDynamicStreams(QuicSession* session) {
+ size_t result = 0;
+ for (const auto& it : session->stream_map_) {
+ if (!it.second->is_static()) {
+ ++result;
+ }
+ }
+ // Exclude draining streams.
+ result -= session->num_draining_streams_;
+ // Add locally closed streams.
+ result += session->locally_closed_streams_highest_offset_.size();
+
+ return result;
+}
+
+// static
+size_t QuicSessionPeer::GetNumDrainingStreams(QuicSession* session) {
+ return session->num_draining_streams_;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_session_peer.h b/quiche/quic/test_tools/quic_session_peer.h
new file mode 100644
index 0000000..b01c925
--- /dev/null
+++ b/quiche/quic/test_tools/quic_session_peer.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
+
+#include <cstdint>
+#include <map>
+#include <memory>
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_write_blocked_list.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+
+namespace quic {
+
+class QuicCryptoStream;
+class QuicSession;
+class QuicStream;
+
+namespace test {
+
+class QuicSessionPeer {
+ public:
+ QuicSessionPeer() = delete;
+
+ static QuicStreamId GetNextOutgoingBidirectionalStreamId(
+ QuicSession* session);
+ static QuicStreamId GetNextOutgoingUnidirectionalStreamId(
+ QuicSession* session);
+ static void SetNextOutgoingBidirectionalStreamId(QuicSession* session,
+ QuicStreamId id);
+ // Following is only for Google-QUIC, will QUIC_BUG if called for IETF
+ // QUIC.
+ static void SetMaxOpenIncomingStreams(QuicSession* session,
+ uint32_t max_streams);
+ // Following two are only for IETF-QUIC, will QUIC_BUG if called for Google
+ // QUIC.
+ static void SetMaxOpenIncomingBidirectionalStreams(QuicSession* session,
+ uint32_t max_streams);
+ static void SetMaxOpenIncomingUnidirectionalStreams(QuicSession* session,
+ uint32_t max_streams);
+
+ static void SetMaxOpenOutgoingStreams(QuicSession* session,
+ uint32_t max_streams);
+ static void SetMaxOpenOutgoingBidirectionalStreams(QuicSession* session,
+ uint32_t max_streams);
+ static void SetMaxOpenOutgoingUnidirectionalStreams(QuicSession* session,
+ uint32_t max_streams);
+
+ static QuicCryptoStream* GetMutableCryptoStream(QuicSession* session);
+ static QuicWriteBlockedList* GetWriteBlockedStreams(QuicSession* session);
+ static QuicStream* GetOrCreateStream(QuicSession* session,
+ QuicStreamId stream_id);
+ static absl::flat_hash_map<QuicStreamId, QuicStreamOffset>&
+ GetLocallyClosedStreamsHighestOffset(QuicSession* session);
+ static QuicSession::StreamMap& stream_map(QuicSession* session);
+ static const QuicSession::ClosedStreams& closed_streams(QuicSession* session);
+ static void ActivateStream(QuicSession* session,
+ std::unique_ptr<QuicStream> stream);
+
+ // Discern the state of a stream. Exactly one of these should be true at a
+ // time for any stream id > 0 (other than the special streams 1 and 3).
+ static bool IsStreamClosed(QuicSession* session, QuicStreamId id);
+ static bool IsStreamCreated(QuicSession* session, QuicStreamId id);
+ static bool IsStreamAvailable(QuicSession* session, QuicStreamId id);
+
+ static QuicStream* GetStream(QuicSession* session, QuicStreamId id);
+ static bool IsStreamWriteBlocked(QuicSession* session, QuicStreamId id);
+ static QuicAlarm* GetCleanUpClosedStreamsAlarm(QuicSession* session);
+ static LegacyQuicStreamIdManager* GetStreamIdManager(QuicSession* session);
+ static UberQuicStreamIdManager* ietf_streamid_manager(QuicSession* session);
+ static QuicStreamIdManager* ietf_bidirectional_stream_id_manager(
+ QuicSession* session);
+ static QuicStreamIdManager* ietf_unidirectional_stream_id_manager(
+ QuicSession* session);
+ static PendingStream* GetPendingStream(QuicSession* session,
+ QuicStreamId stream_id);
+ static void set_is_configured(QuicSession* session, bool value);
+ static void SetPerspective(QuicSession* session, Perspective perspective);
+ static size_t GetNumOpenDynamicStreams(QuicSession* session);
+ static size_t GetNumDrainingStreams(QuicSession* session);
+ static QuicStreamId GetLargestPeerCreatedStreamId(QuicSession* session,
+ bool unidirectional) {
+ return session->GetLargestPeerCreatedStreamId(unidirectional);
+ }
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
diff --git a/quiche/quic/test_tools/quic_spdy_session_peer.cc b/quiche/quic/test_tools/quic_spdy_session_peer.cc
new file mode 100644
index 0000000..62348cb
--- /dev/null
+++ b/quiche/quic/test_tools/quic_spdy_session_peer.cc
@@ -0,0 +1,119 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_spdy_session_peer.h"
+
+#include "quiche/quic/core/http/quic_spdy_session.h"
+#include "quiche/quic/core/qpack/qpack_receive_stream.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/test_tools/quic_session_peer.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+
+namespace quic {
+namespace test {
+
+// static
+QuicHeadersStream* QuicSpdySessionPeer::GetHeadersStream(
+ QuicSpdySession* session) {
+ QUICHE_DCHECK(!VersionUsesHttp3(session->transport_version()));
+ return session->headers_stream();
+}
+
+void QuicSpdySessionPeer::SetHeadersStream(QuicSpdySession* session,
+ QuicHeadersStream* headers_stream) {
+ QUICHE_DCHECK(!VersionUsesHttp3(session->transport_version()));
+ for (auto& it : QuicSessionPeer::stream_map(session)) {
+ if (it.first ==
+ QuicUtils::GetHeadersStreamId(session->transport_version())) {
+ it.second.reset(headers_stream);
+ session->headers_stream_ = static_cast<QuicHeadersStream*>(it.second.get());
+ break;
+ }
+ }
+}
+
+// static
+spdy::SpdyFramer* QuicSpdySessionPeer::GetSpdyFramer(QuicSpdySession* session) {
+ return &session->spdy_framer_;
+}
+
+void QuicSpdySessionPeer::SetMaxInboundHeaderListSize(
+ QuicSpdySession* session, size_t max_inbound_header_size) {
+ session->set_max_inbound_header_list_size(max_inbound_header_size);
+}
+
+// static
+size_t QuicSpdySessionPeer::WriteHeadersOnHeadersStream(
+ QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+ bool fin, const spdy::SpdyStreamPrecedence& precedence,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
+ return session->WriteHeadersOnHeadersStream(
+ id, std::move(headers), fin, precedence, std::move(ack_listener));
+}
+
+// static
+QuicStreamId QuicSpdySessionPeer::GetNextOutgoingUnidirectionalStreamId(
+ QuicSpdySession* session) {
+ return session->GetNextOutgoingUnidirectionalStreamId();
+}
+
+// static
+QuicReceiveControlStream* QuicSpdySessionPeer::GetReceiveControlStream(
+ QuicSpdySession* session) {
+ return session->receive_control_stream_;
+}
+
+// static
+QuicSendControlStream* QuicSpdySessionPeer::GetSendControlStream(
+ QuicSpdySession* session) {
+ return session->send_control_stream_;
+}
+
+// static
+QpackSendStream* QuicSpdySessionPeer::GetQpackDecoderSendStream(
+ QuicSpdySession* session) {
+ return session->qpack_decoder_send_stream_;
+}
+
+// static
+QpackSendStream* QuicSpdySessionPeer::GetQpackEncoderSendStream(
+ QuicSpdySession* session) {
+ return session->qpack_encoder_send_stream_;
+}
+
+// static
+QpackReceiveStream* QuicSpdySessionPeer::GetQpackDecoderReceiveStream(
+ QuicSpdySession* session) {
+ return session->qpack_decoder_receive_stream_;
+}
+
+// static
+QpackReceiveStream* QuicSpdySessionPeer::GetQpackEncoderReceiveStream(
+ QuicSpdySession* session) {
+ return session->qpack_encoder_receive_stream_;
+}
+
+// static
+void QuicSpdySessionPeer::SetHttpDatagramSupport(
+ QuicSpdySession* session, HttpDatagramSupport http_datagram_support) {
+ session->http_datagram_support_ = http_datagram_support;
+}
+
+// static
+HttpDatagramSupport QuicSpdySessionPeer::LocalHttpDatagramSupport(
+ QuicSpdySession* session) {
+ return session->LocalHttpDatagramSupport();
+}
+
+// static
+void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession* session) {
+ QUICHE_DCHECK(session->WillNegotiateWebTransport());
+ SetHttpDatagramSupport(session, HttpDatagramSupport::kDraft04);
+ session->peer_supports_webtransport_ = true;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_spdy_session_peer.h b/quiche/quic/test_tools/quic_spdy_session_peer.h
new file mode 100644
index 0000000..d87104f
--- /dev/null
+++ b/quiche/quic/test_tools/quic_spdy_session_peer.h
@@ -0,0 +1,61 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_SESSION_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_SESSION_PEER_H_
+
+#include "quiche/quic/core/http/quic_receive_control_stream.h"
+#include "quiche/quic/core/http/quic_send_control_stream.h"
+#include "quiche/quic/core/http/quic_spdy_session.h"
+#include "quiche/quic/core/qpack/qpack_receive_stream.h"
+#include "quiche/quic/core/qpack/qpack_send_stream.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_write_blocked_list.h"
+#include "quiche/spdy/core/spdy_framer.h"
+
+namespace quic {
+
+class QuicHeadersStream;
+
+namespace test {
+
+class QuicSpdySessionPeer {
+ public:
+ QuicSpdySessionPeer() = delete;
+
+ static QuicHeadersStream* GetHeadersStream(QuicSpdySession* session);
+ static void SetHeadersStream(QuicSpdySession* session,
+ QuicHeadersStream* headers_stream);
+ static spdy::SpdyFramer* GetSpdyFramer(QuicSpdySession* session);
+ // Must be called before Initialize().
+ static void SetMaxInboundHeaderListSize(QuicSpdySession* session,
+ size_t max_inbound_header_size);
+ static size_t WriteHeadersOnHeadersStream(
+ QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+ bool fin, const spdy::SpdyStreamPrecedence& precedence,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
+ // |session| can't be nullptr.
+ static QuicStreamId GetNextOutgoingUnidirectionalStreamId(
+ QuicSpdySession* session);
+ static QuicReceiveControlStream* GetReceiveControlStream(
+ QuicSpdySession* session);
+ static QuicSendControlStream* GetSendControlStream(QuicSpdySession* session);
+ static QpackSendStream* GetQpackDecoderSendStream(QuicSpdySession* session);
+ static QpackSendStream* GetQpackEncoderSendStream(QuicSpdySession* session);
+ static QpackReceiveStream* GetQpackDecoderReceiveStream(
+ QuicSpdySession* session);
+ static QpackReceiveStream* GetQpackEncoderReceiveStream(
+ QuicSpdySession* session);
+ static void SetHttpDatagramSupport(QuicSpdySession* session,
+ HttpDatagramSupport http_datagram_support);
+ static HttpDatagramSupport LocalHttpDatagramSupport(QuicSpdySession* session);
+ static void EnableWebTransport(QuicSpdySession* session);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_SESSION_PEER_H_
diff --git a/quiche/quic/test_tools/quic_spdy_stream_peer.cc b/quiche/quic/test_tools/quic_spdy_stream_peer.cc
new file mode 100644
index 0000000..d2ec5fd
--- /dev/null
+++ b/quiche/quic/test_tools/quic_spdy_stream_peer.cc
@@ -0,0 +1,38 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_spdy_stream_peer.h"
+
+#include "quiche/quic/core/http/quic_spdy_stream.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicSpdyStreamPeer::set_ack_listener(
+ QuicSpdyStream* stream,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
+ stream->set_ack_listener(std::move(ack_listener));
+}
+
+// static
+const QuicIntervalSet<QuicStreamOffset>&
+QuicSpdyStreamPeer::unacked_frame_headers_offsets(QuicSpdyStream* stream) {
+ return stream->unacked_frame_headers_offsets_;
+}
+
+// static
+bool QuicSpdyStreamPeer::use_datagram_contexts(QuicSpdyStream* stream) {
+ return stream->use_datagram_contexts_;
+}
+
+// static
+bool QuicSpdyStreamPeer::OnHeadersFrameEnd(QuicSpdyStream* stream) {
+ return stream->OnHeadersFrameEnd();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_spdy_stream_peer.h b/quiche/quic/test_tools/quic_spdy_stream_peer.h
new file mode 100644
index 0000000..e92f89e
--- /dev/null
+++ b/quiche/quic/test_tools/quic_spdy_stream_peer.h
@@ -0,0 +1,35 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_STREAM_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_STREAM_PEER_H_
+
+#include "quiche/quic/core/quic_ack_listener_interface.h"
+#include "quiche/quic/core/quic_interval_set.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+
+namespace quic {
+
+class QpackDecodedHeadersAccumulator;
+class QuicSpdyStream;
+
+namespace test {
+
+class QuicSpdyStreamPeer {
+ public:
+ static void set_ack_listener(
+ QuicSpdyStream* stream,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
+ static const QuicIntervalSet<QuicStreamOffset>& unacked_frame_headers_offsets(
+ QuicSpdyStream* stream);
+ static bool use_datagram_contexts(QuicSpdyStream* stream);
+ static bool OnHeadersFrameEnd(QuicSpdyStream* stream);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SPDY_STREAM_PEER_H_
diff --git a/quiche/quic/test_tools/quic_stream_id_manager_peer.cc b/quiche/quic/test_tools/quic_stream_id_manager_peer.cc
new file mode 100644
index 0000000..0bec142
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_id_manager_peer.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include "quiche/quic/test_tools/quic_stream_id_manager_peer.h"
+
+#include "quiche/quic/core/quic_stream_id_manager.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/core/uber_quic_stream_id_manager.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicStreamIdManagerPeer::set_incoming_actual_max_streams(
+ QuicStreamIdManager* stream_id_manager,
+ QuicStreamCount count) {
+ stream_id_manager->incoming_actual_max_streams_ = count;
+}
+
+// static
+void QuicStreamIdManagerPeer::set_outgoing_max_streams(
+ QuicStreamIdManager* stream_id_manager,
+ QuicStreamCount count) {
+ stream_id_manager->outgoing_max_streams_ = count;
+}
+
+// static
+QuicStreamId QuicStreamIdManagerPeer::GetFirstIncomingStreamId(
+ QuicStreamIdManager* stream_id_manager) {
+ return stream_id_manager->GetFirstIncomingStreamId();
+}
+
+// static
+bool QuicStreamIdManagerPeer::get_unidirectional(
+ QuicStreamIdManager* stream_id_manager) {
+ return stream_id_manager->unidirectional_;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_stream_id_manager_peer.h b/quiche/quic/test_tools/quic_stream_id_manager_peer.h
new file mode 100644
index 0000000..68799e2
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_id_manager_peer.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_ID_MANAGER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_ID_MANAGER_PEER_H_
+
+#include <stddef.h>
+
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+
+class QuicStreamIdManager;
+class UberQuicStreamIdManager;
+
+namespace test {
+
+class QuicStreamIdManagerPeer {
+ public:
+ QuicStreamIdManagerPeer() = delete;
+
+ static void set_incoming_actual_max_streams(
+ QuicStreamIdManager* stream_id_manager,
+ QuicStreamCount count);
+ static void set_outgoing_max_streams(QuicStreamIdManager* stream_id_manager,
+ QuicStreamCount count);
+
+ static QuicStreamId GetFirstIncomingStreamId(
+ QuicStreamIdManager* stream_id_manager);
+
+ static bool get_unidirectional(QuicStreamIdManager* stream_id_manager);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
diff --git a/quiche/quic/test_tools/quic_stream_peer.cc b/quiche/quic/test_tools/quic_stream_peer.cc
new file mode 100644
index 0000000..594cb89
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_peer.cc
@@ -0,0 +1,120 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_stream_peer.h"
+
+#include <list>
+
+#include "quiche/quic/core/quic_stream.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/test_tools/quic_flow_controller_peer.h"
+#include "quiche/quic/test_tools/quic_stream_send_buffer_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicStreamPeer::SetWriteSideClosed(bool value, QuicStream* stream) {
+ stream->write_side_closed_ = value;
+}
+
+// static
+void QuicStreamPeer::SetStreamBytesWritten(
+ QuicStreamOffset stream_bytes_written,
+ QuicStream* stream) {
+ stream->send_buffer_.stream_bytes_written_ = stream_bytes_written;
+ stream->send_buffer_.stream_bytes_outstanding_ = stream_bytes_written;
+ QuicStreamSendBufferPeer::SetStreamOffset(&stream->send_buffer_,
+ stream_bytes_written);
+}
+
+// static
+void QuicStreamPeer::SetSendWindowOffset(QuicStream* stream,
+ QuicStreamOffset offset) {
+ QuicFlowControllerPeer::SetSendWindowOffset(&*stream->flow_controller_,
+ offset);
+}
+
+// static
+QuicByteCount QuicStreamPeer::bytes_consumed(QuicStream* stream) {
+ return stream->flow_controller_->bytes_consumed();
+}
+
+// static
+void QuicStreamPeer::SetReceiveWindowOffset(QuicStream* stream,
+ QuicStreamOffset offset) {
+ QuicFlowControllerPeer::SetReceiveWindowOffset(&*stream->flow_controller_,
+ offset);
+}
+
+// static
+void QuicStreamPeer::SetMaxReceiveWindow(QuicStream* stream,
+ QuicStreamOffset size) {
+ QuicFlowControllerPeer::SetMaxReceiveWindow(&*stream->flow_controller_, size);
+}
+
+// static
+QuicByteCount QuicStreamPeer::SendWindowSize(QuicStream* stream) {
+ return stream->flow_controller_->SendWindowSize();
+}
+
+// static
+QuicStreamOffset QuicStreamPeer::ReceiveWindowOffset(QuicStream* stream) {
+ return QuicFlowControllerPeer::ReceiveWindowOffset(
+ &*stream->flow_controller_);
+}
+
+// static
+QuicByteCount QuicStreamPeer::ReceiveWindowSize(QuicStream* stream) {
+ return QuicFlowControllerPeer::ReceiveWindowSize(&*stream->flow_controller_);
+}
+
+// static
+QuicStreamOffset QuicStreamPeer::SendWindowOffset(QuicStream* stream) {
+ return stream->flow_controller_->send_window_offset();
+}
+
+// static
+bool QuicStreamPeer::read_side_closed(QuicStream* stream) {
+ return stream->read_side_closed_;
+}
+
+// static
+void QuicStreamPeer::CloseReadSide(QuicStream* stream) {
+ stream->CloseReadSide();
+}
+
+// static
+bool QuicStreamPeer::StreamContributesToConnectionFlowControl(
+ QuicStream* stream) {
+ return stream->stream_contributes_to_connection_flow_control_;
+}
+
+// static
+QuicStreamSequencer* QuicStreamPeer::sequencer(QuicStream* stream) {
+ return &(stream->sequencer_);
+}
+
+// static
+QuicSession* QuicStreamPeer::session(QuicStream* stream) {
+ return stream->session();
+}
+
+// static
+QuicStreamSendBuffer& QuicStreamPeer::SendBuffer(QuicStream* stream) {
+ return stream->send_buffer_;
+}
+
+// static
+void QuicStreamPeer::SetFinReceived(QuicStream* stream) {
+ stream->fin_received_ = true;
+}
+
+// static
+void QuicStreamPeer::SetFinSent(QuicStream* stream) {
+ stream->fin_sent_ = true;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_stream_peer.h b/quiche/quic/test_tools/quic_stream_peer.h
new file mode 100644
index 0000000..3525deb
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_peer.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_PEER_H_
+
+#include <cstdint>
+
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_stream_send_buffer.h"
+#include "quiche/quic/core/quic_stream_sequencer.h"
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+
+class QuicStream;
+class QuicSession;
+
+namespace test {
+
+class QuicStreamPeer {
+ public:
+ QuicStreamPeer() = delete;
+
+ static void SetWriteSideClosed(bool value, QuicStream* stream);
+ static void SetStreamBytesWritten(QuicStreamOffset stream_bytes_written,
+ QuicStream* stream);
+ static void SetSendWindowOffset(QuicStream* stream, QuicStreamOffset offset);
+ static void SetReceiveWindowOffset(QuicStream* stream,
+ QuicStreamOffset offset);
+ static void SetMaxReceiveWindow(QuicStream* stream, QuicStreamOffset size);
+ static bool read_side_closed(QuicStream* stream);
+ static void CloseReadSide(QuicStream* stream);
+ static QuicByteCount bytes_consumed(QuicStream* stream);
+ static QuicByteCount ReceiveWindowSize(QuicStream* stream);
+ static QuicByteCount SendWindowSize(QuicStream* stream);
+ static QuicStreamOffset SendWindowOffset(QuicStream* stream);
+ static QuicStreamOffset ReceiveWindowOffset(QuicStream* stream);
+
+ static bool StreamContributesToConnectionFlowControl(QuicStream* stream);
+
+ static QuicStreamSequencer* sequencer(QuicStream* stream);
+ static QuicSession* session(QuicStream* stream);
+ static void SetFinReceived(QuicStream* stream);
+ static void SetFinSent(QuicStream* stream);
+
+ static QuicStreamSendBuffer& SendBuffer(QuicStream* stream);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_PEER_H_
diff --git a/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
new file mode 100644
index 0000000..e4554fa
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
@@ -0,0 +1,54 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_stream_send_buffer_peer.h"
+#include "quiche/quic/test_tools/quic_interval_deque_peer.h"
+
+namespace quic {
+
+namespace test {
+
+// static
+void QuicStreamSendBufferPeer::SetStreamOffset(
+ QuicStreamSendBuffer* send_buffer,
+ QuicStreamOffset stream_offset) {
+ send_buffer->stream_offset_ = stream_offset;
+}
+
+// static
+const BufferedSlice* QuicStreamSendBufferPeer::CurrentWriteSlice(
+ QuicStreamSendBuffer* send_buffer) {
+ auto wi = write_index(send_buffer);
+
+ if (wi == -1) {
+ return nullptr;
+ }
+ return QuicIntervalDequePeer::GetItem(&send_buffer->interval_deque_, wi);
+}
+
+QuicStreamOffset QuicStreamSendBufferPeer::EndOffset(
+ QuicStreamSendBuffer* send_buffer) {
+ return send_buffer->current_end_offset_;
+}
+
+// static
+QuicByteCount QuicStreamSendBufferPeer::TotalLength(
+ QuicStreamSendBuffer* send_buffer) {
+ QuicByteCount length = 0;
+ for (auto slice = send_buffer->interval_deque_.DataBegin();
+ slice != send_buffer->interval_deque_.DataEnd(); ++slice) {
+ length += slice->slice.length();
+ }
+ return length;
+}
+
+// static
+int32_t QuicStreamSendBufferPeer::write_index(
+ QuicStreamSendBuffer* send_buffer) {
+ return QuicIntervalDequePeer::GetCachedIndex(&send_buffer->interval_deque_);
+}
+
+} // namespace test
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_stream_send_buffer_peer.h b/quiche/quic/test_tools/quic_stream_send_buffer_peer.h
new file mode 100644
index 0000000..9792290
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_send_buffer_peer.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEND_BUFFER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEND_BUFFER_PEER_H_
+
+#include "quiche/quic/core/quic_stream_send_buffer.h"
+
+namespace quic {
+
+namespace test {
+
+class QuicStreamSendBufferPeer {
+ public:
+ static void SetStreamOffset(QuicStreamSendBuffer* send_buffer,
+ QuicStreamOffset stream_offset);
+
+ static const BufferedSlice* CurrentWriteSlice(
+ QuicStreamSendBuffer* send_buffer);
+
+ static QuicStreamOffset EndOffset(QuicStreamSendBuffer* send_buffer);
+
+ static QuicByteCount TotalLength(QuicStreamSendBuffer* send_buffer);
+
+ static int32_t write_index(QuicStreamSendBuffer* send_buffer);
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEND_BUFFER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
new file mode 100644
index 0000000..63d8a4b
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
@@ -0,0 +1,162 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
+#include <cstddef>
+
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+using BufferBlock = quic::QuicStreamSequencerBuffer::BufferBlock;
+
+static const size_t kBlockSizeBytes =
+ quic::QuicStreamSequencerBuffer::kBlockSizeBytes;
+
+namespace quic {
+namespace test {
+
+QuicStreamSequencerBufferPeer::QuicStreamSequencerBufferPeer(
+ QuicStreamSequencerBuffer* buffer)
+ : buffer_(buffer) {}
+
+// Read from this buffer_ into the given destination buffer_ up to the
+// size of the destination. Returns the number of bytes read. Reading from
+// an empty buffer_->returns 0.
+size_t QuicStreamSequencerBufferPeer::Read(char* dest_buffer, size_t size) {
+ iovec dest;
+ dest.iov_base = dest_buffer, dest.iov_len = size;
+ size_t bytes_read;
+ std::string error_details;
+ EXPECT_THAT(buffer_->Readv(&dest, 1, &bytes_read, &error_details),
+ IsQuicNoError());
+ return bytes_read;
+}
+
+// If buffer is empty, the blocks_ array must be empty, which means all
+// blocks are deallocated.
+bool QuicStreamSequencerBufferPeer::CheckEmptyInvariants() {
+ return !buffer_->Empty() || IsBlockArrayEmpty();
+}
+
+bool QuicStreamSequencerBufferPeer::IsBlockArrayEmpty() {
+ if (buffer_->blocks_ == nullptr) {
+ return true;
+ }
+
+ size_t count = current_blocks_count();
+ for (size_t i = 0; i < count; i++) {
+ if (buffer_->blocks_[i] != nullptr) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool QuicStreamSequencerBufferPeer::CheckInitialState() {
+ EXPECT_TRUE(buffer_->Empty() && buffer_->total_bytes_read_ == 0 &&
+ buffer_->num_bytes_buffered_ == 0);
+ return CheckBufferInvariants();
+}
+
+bool QuicStreamSequencerBufferPeer::CheckBufferInvariants() {
+ QuicStreamOffset data_span =
+ buffer_->NextExpectedByte() - buffer_->total_bytes_read_;
+ bool capacity_sane = data_span <= buffer_->max_buffer_capacity_bytes_ &&
+ data_span >= buffer_->num_bytes_buffered_;
+ if (!capacity_sane) {
+ QUIC_LOG(ERROR) << "data span is larger than capacity.";
+ QUIC_LOG(ERROR) << "total read: " << buffer_->total_bytes_read_
+ << " last byte: " << buffer_->NextExpectedByte();
+ }
+ bool total_read_sane =
+ buffer_->FirstMissingByte() >= buffer_->total_bytes_read_;
+ if (!total_read_sane) {
+ QUIC_LOG(ERROR) << "read across 1st gap.";
+ }
+ bool read_offset_sane = buffer_->ReadOffset() < kBlockSizeBytes;
+ if (!capacity_sane) {
+ QUIC_LOG(ERROR) << "read offset go beyond 1st block";
+ }
+ bool block_match_capacity =
+ (buffer_->max_buffer_capacity_bytes_ <=
+ buffer_->max_blocks_count_ * kBlockSizeBytes) &&
+ (buffer_->max_buffer_capacity_bytes_ >
+ (buffer_->max_blocks_count_ - 1) * kBlockSizeBytes);
+ if (!capacity_sane) {
+ QUIC_LOG(ERROR) << "block number not match capcaity.";
+ }
+ bool block_retired_when_empty = CheckEmptyInvariants();
+ if (!block_retired_when_empty) {
+ QUIC_LOG(ERROR) << "block is not retired after use.";
+ }
+ return capacity_sane && total_read_sane && read_offset_sane &&
+ block_match_capacity && block_retired_when_empty;
+}
+
+size_t QuicStreamSequencerBufferPeer::GetInBlockOffset(
+ QuicStreamOffset offset) {
+ return buffer_->GetInBlockOffset(offset);
+}
+
+BufferBlock* QuicStreamSequencerBufferPeer::GetBlock(size_t index) {
+ return buffer_->blocks_[index];
+}
+
+int QuicStreamSequencerBufferPeer::IntervalSize() {
+ if (buffer_->bytes_received_.Empty()) {
+ return 1;
+ }
+ int gap_size = buffer_->bytes_received_.Size() + 1;
+ if (buffer_->bytes_received_.Empty()) {
+ return gap_size;
+ }
+ if (buffer_->bytes_received_.begin()->min() == 0) {
+ --gap_size;
+ }
+ if (buffer_->bytes_received_.rbegin()->max() ==
+ std::numeric_limits<uint64_t>::max()) {
+ --gap_size;
+ }
+ return gap_size;
+}
+
+size_t QuicStreamSequencerBufferPeer::max_buffer_capacity() {
+ return buffer_->max_buffer_capacity_bytes_;
+}
+
+size_t QuicStreamSequencerBufferPeer::ReadableBytes() {
+ return buffer_->ReadableBytes();
+}
+
+void QuicStreamSequencerBufferPeer::set_total_bytes_read(
+ QuicStreamOffset total_bytes_read) {
+ buffer_->total_bytes_read_ = total_bytes_read;
+}
+
+void QuicStreamSequencerBufferPeer::AddBytesReceived(QuicStreamOffset offset,
+ QuicByteCount length) {
+ buffer_->bytes_received_.Add(offset, offset + length);
+}
+
+bool QuicStreamSequencerBufferPeer::IsBufferAllocated() {
+ return buffer_->blocks_ != nullptr;
+}
+
+size_t QuicStreamSequencerBufferPeer::max_blocks_count() {
+ return buffer_->max_blocks_count_;
+}
+
+size_t QuicStreamSequencerBufferPeer::current_blocks_count() {
+ return buffer_->current_blocks_count_;
+}
+
+const QuicIntervalSet<QuicStreamOffset>&
+QuicStreamSequencerBufferPeer::bytes_received() {
+ return buffer_->bytes_received_;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h
new file mode 100644
index 0000000..eac892a
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_BUFFER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_BUFFER_PEER_H_
+
+#include "quiche/quic/core/quic_stream_sequencer_buffer.h"
+
+namespace quic {
+
+namespace test {
+
+class QuicStreamSequencerBufferPeer {
+ public:
+ explicit QuicStreamSequencerBufferPeer(QuicStreamSequencerBuffer* buffer);
+ QuicStreamSequencerBufferPeer(const QuicStreamSequencerBufferPeer&) = delete;
+ QuicStreamSequencerBufferPeer& operator=(
+ const QuicStreamSequencerBufferPeer&) = delete;
+
+ // Read from this buffer_ into the given destination buffer_ up to the
+ // size of the destination. Returns the number of bytes read. Reading from
+ // an empty buffer_->returns 0.
+ size_t Read(char* dest_buffer, size_t size);
+
+ // If buffer is empty, the blocks_ array must be empty, which means all
+ // blocks are deallocated.
+ bool CheckEmptyInvariants();
+
+ bool IsBlockArrayEmpty();
+
+ bool CheckInitialState();
+
+ bool CheckBufferInvariants();
+
+ size_t GetInBlockOffset(QuicStreamOffset offset);
+
+ QuicStreamSequencerBuffer::BufferBlock* GetBlock(size_t index);
+
+ int IntervalSize();
+
+ size_t max_buffer_capacity();
+
+ size_t ReadableBytes();
+
+ void set_total_bytes_read(QuicStreamOffset total_bytes_read);
+
+ void AddBytesReceived(QuicStreamOffset offset, QuicByteCount length);
+
+ bool IsBufferAllocated();
+
+ size_t max_blocks_count();
+
+ size_t current_blocks_count();
+
+ const QuicIntervalSet<QuicStreamOffset>& bytes_received();
+
+ private:
+ QuicStreamSequencerBuffer* buffer_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_BUFFER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_peer.cc b/quiche/quic/test_tools/quic_stream_sequencer_peer.cc
new file mode 100644
index 0000000..100f38e
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_sequencer_peer.cc
@@ -0,0 +1,40 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_stream_sequencer_peer.h"
+
+#include "quiche/quic/core/quic_stream_sequencer.h"
+#include "quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+size_t QuicStreamSequencerPeer::GetNumBufferedBytes(
+ QuicStreamSequencer* sequencer) {
+ return sequencer->buffered_frames_.BytesBuffered();
+}
+
+// static
+QuicStreamOffset QuicStreamSequencerPeer::GetCloseOffset(
+ QuicStreamSequencer* sequencer) {
+ return sequencer->close_offset_;
+}
+
+// static
+bool QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(
+ QuicStreamSequencer* sequencer) {
+ QuicStreamSequencerBufferPeer buffer_peer(&(sequencer->buffered_frames_));
+ return buffer_peer.IsBufferAllocated();
+}
+
+// static
+void QuicStreamSequencerPeer::SetFrameBufferTotalBytesRead(
+ QuicStreamSequencer* sequencer,
+ QuicStreamOffset total_bytes_read) {
+ QuicStreamSequencerBufferPeer buffer_peer(&(sequencer->buffered_frames_));
+ buffer_peer.set_total_bytes_read(total_bytes_read);
+}
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_peer.h b/quiche/quic/test_tools/quic_stream_sequencer_peer.h
new file mode 100644
index 0000000..4be113f
--- /dev/null
+++ b/quiche/quic/test_tools/quic_stream_sequencer_peer.h
@@ -0,0 +1,33 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_PEER_H_
+
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+
+class QuicStreamSequencer;
+
+namespace test {
+
+class QuicStreamSequencerPeer {
+ public:
+ QuicStreamSequencerPeer() = delete;
+
+ static size_t GetNumBufferedBytes(QuicStreamSequencer* sequencer);
+
+ static QuicStreamOffset GetCloseOffset(QuicStreamSequencer* sequencer);
+
+ static bool IsUnderlyingBufferAllocated(QuicStreamSequencer* sequencer);
+
+ static void SetFrameBufferTotalBytesRead(QuicStreamSequencer* sequencer,
+ QuicStreamOffset total_bytes_read);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_STREAM_SEQUENCER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.cc b/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.cc
new file mode 100644
index 0000000..46fa83c
--- /dev/null
+++ b/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.cc
@@ -0,0 +1,34 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h"
+
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_sustained_bandwidth_recorder.h"
+
+namespace quic {
+namespace test {
+
+// static
+void QuicSustainedBandwidthRecorderPeer::SetBandwidthEstimate(
+ QuicSustainedBandwidthRecorder* bandwidth_recorder,
+ int32_t bandwidth_estimate_kbytes_per_second) {
+ bandwidth_recorder->has_estimate_ = true;
+ bandwidth_recorder->bandwidth_estimate_ =
+ QuicBandwidth::FromKBytesPerSecond(bandwidth_estimate_kbytes_per_second);
+}
+
+// static
+void QuicSustainedBandwidthRecorderPeer::SetMaxBandwidthEstimate(
+ QuicSustainedBandwidthRecorder* bandwidth_recorder,
+ int32_t max_bandwidth_estimate_kbytes_per_second,
+ int32_t max_bandwidth_timestamp) {
+ bandwidth_recorder->max_bandwidth_estimate_ =
+ QuicBandwidth::FromKBytesPerSecond(
+ max_bandwidth_estimate_kbytes_per_second);
+ bandwidth_recorder->max_bandwidth_timestamp_ = max_bandwidth_timestamp;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h b/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h
new file mode 100644
index 0000000..b60412c
--- /dev/null
+++ b/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h
@@ -0,0 +1,35 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_SUSTAINED_BANDWIDTH_RECORDER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_SUSTAINED_BANDWIDTH_RECORDER_PEER_H_
+
+#include <cstdint>
+
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+
+class QuicSustainedBandwidthRecorder;
+
+namespace test {
+
+class QuicSustainedBandwidthRecorderPeer {
+ public:
+ QuicSustainedBandwidthRecorderPeer() = delete;
+
+ static void SetBandwidthEstimate(
+ QuicSustainedBandwidthRecorder* bandwidth_recorder,
+ int32_t bandwidth_estimate_kbytes_per_second);
+
+ static void SetMaxBandwidthEstimate(
+ QuicSustainedBandwidthRecorder* bandwidth_recorder,
+ int32_t max_bandwidth_estimate_kbytes_per_second,
+ int32_t max_bandwidth_timestamp);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_SUSTAINED_BANDWIDTH_RECORDER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_test_backend.cc b/quiche/quic/test_tools/quic_test_backend.cc
new file mode 100644
index 0000000..756c560
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_backend.cc
@@ -0,0 +1,120 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_test_backend.h"
+
+#include <cstring>
+#include <memory>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/test_tools/web_transport_resets_backend.h"
+#include "quiche/quic/tools/web_transport_test_visitors.h"
+
+namespace quic {
+namespace test {
+
+namespace {
+
+// SessionCloseVisitor implements the "/session-close" endpoint. If the client
+// sends a unidirectional stream of format "code message" to this endpoint, it
+// will close the session with the corresponding error code and error message.
+// For instance, sending "42 test error" will cause it to be closed with code 42
+// and message "test error".
+class SessionCloseVisitor : public WebTransportVisitor {
+ public:
+ SessionCloseVisitor(WebTransportSession* session) : session_(session) {}
+
+ void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+ void OnSessionClosed(WebTransportSessionError /*error_code*/,
+ const std::string& /*error_message*/) override {}
+
+ void OnIncomingBidirectionalStreamAvailable() override {}
+ void OnIncomingUnidirectionalStreamAvailable() override {
+ WebTransportStream* stream = session_->AcceptIncomingUnidirectionalStream();
+ if (stream == nullptr) {
+ return;
+ }
+ stream->SetVisitor(
+ std::make_unique<WebTransportUnidirectionalEchoReadVisitor>(
+ stream, [this](const std::string& data) {
+ std::pair<absl::string_view, absl::string_view> parsed =
+ absl::StrSplit(data, absl::MaxSplits(' ', 1));
+ WebTransportSessionError error_code = 0;
+ bool success = absl::SimpleAtoi(parsed.first, &error_code);
+ QUICHE_DCHECK(success) << data;
+ session_->CloseSession(error_code, parsed.second);
+ }));
+ stream->visitor()->OnCanRead();
+ }
+
+ void OnDatagramReceived(absl::string_view /*datagram*/) override {}
+
+ void OnCanCreateNewOutgoingBidirectionalStream() override {}
+ void OnCanCreateNewOutgoingUnidirectionalStream() override {}
+
+ private:
+ WebTransportSession* session_; // Not owned.
+};
+
+} // namespace
+
+QuicSimpleServerBackend::WebTransportResponse
+QuicTestBackend::ProcessWebTransportRequest(
+ const spdy::Http2HeaderBlock& request_headers,
+ WebTransportSession* session) {
+ if (!SupportsWebTransport()) {
+ return QuicSimpleServerBackend::ProcessWebTransportRequest(request_headers,
+ session);
+ }
+
+ auto path_it = request_headers.find(":path");
+ if (path_it == request_headers.end()) {
+ WebTransportResponse response;
+ response.response_headers[":status"] = "400";
+ return response;
+ }
+ absl::string_view path = path_it->second;
+ // Match any "/echo.*" pass, e.g. "/echo_foobar"
+ if (absl::StartsWith(path, "/echo")) {
+ WebTransportResponse response;
+ response.response_headers[":status"] = "200";
+ // Add response headers if the paramer has "set-header=XXX:YYY" query.
+ GURL url = GURL(absl::StrCat("https://localhost", path));
+ const std::vector<std::string>& params = absl::StrSplit(url.query(), '&');
+ for (const auto& param : params) {
+ absl::string_view param_view = param;
+ if (absl::ConsumePrefix(¶m_view, "set-header=")) {
+ const std::vector<absl::string_view> header_value =
+ absl::StrSplit(param_view, ':');
+ if (header_value.size() == 2 &&
+ !absl::StartsWith(header_value[0], ":")) {
+ response.response_headers[header_value[0]] = header_value[1];
+ }
+ }
+ }
+
+ response.visitor =
+ std::make_unique<EchoWebTransportSessionVisitor>(session);
+ return response;
+ }
+ if (path == "/resets") {
+ return WebTransportResetsBackend(request_headers, session);
+ }
+ if (path == "/session-close") {
+ WebTransportResponse response;
+ response.response_headers[":status"] = "200";
+ response.visitor = std::make_unique<SessionCloseVisitor>(session);
+ return response;
+ }
+
+ WebTransportResponse response;
+ response.response_headers[":status"] = "404";
+ return response;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_test_backend.h b/quiche/quic/test_tools/quic_test_backend.h
new file mode 100644
index 0000000..8fef41a
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_backend.h
@@ -0,0 +1,50 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_BACKEND_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_BACKEND_H_
+
+#include "quiche/quic/tools/quic_memory_cache_backend.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+
+namespace quic {
+namespace test {
+
+// QuicTestBackend is a QuicSimpleServer backend usable in tests. It has extra
+// WebTransport endpoints on top of what QuicMemoryCacheBackend already
+// provides.
+class QuicTestBackend : public QuicMemoryCacheBackend {
+ public:
+ WebTransportResponse ProcessWebTransportRequest(
+ const spdy::Http2HeaderBlock& request_headers,
+ WebTransportSession* session) override;
+ bool SupportsWebTransport() override { return enable_webtransport_; }
+
+ void set_enable_webtransport(bool enable_webtransport) {
+ QUICHE_DCHECK(!enable_webtransport || enable_extended_connect_);
+ enable_webtransport_ = enable_webtransport;
+ }
+
+ bool UsesDatagramContexts() override { return use_datagram_contexts_; }
+
+ void set_use_datagram_contexts(bool use_datagram_contexts) {
+ use_datagram_contexts_ = use_datagram_contexts;
+ }
+
+ bool SupportsExtendedConnect() override { return enable_extended_connect_; }
+
+ void set_enable_extended_connect(bool enable_extended_connect) {
+ enable_extended_connect_ = enable_extended_connect;
+ }
+
+ private:
+ bool enable_webtransport_ = false;
+ bool use_datagram_contexts_ = false;
+ bool enable_extended_connect_ = true;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_BACKEND_H_
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
new file mode 100644
index 0000000..4dd2779
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -0,0 +1,1010 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_test_client.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/match.h"
+#include "absl/strings/string_view.h"
+#include "third_party/boringssl/src/include/openssl/x509.h"
+#include "quiche/quic/core/crypto/proof_verifier.h"
+#include "quiche/quic/core/http/quic_spdy_client_stream.h"
+#include "quiche/quic/core/http/spdy_utils.h"
+#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+#include "quiche/quic/core/quic_server_id.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_stack_trace.h"
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+#include "quiche/quic/test_tools/quic_client_peer.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_spdy_session_peer.h"
+#include "quiche/quic/test_tools/quic_spdy_stream_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/tools/quic_url.h"
+#include "quiche/common/quiche_text_utils.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+// RecordingProofVerifier accepts any certificate chain and records the common
+// name of the leaf and then delegates the actual verification to an actual
+// verifier. If no optional verifier is provided, then VerifyProof will return
+// success.
+class RecordingProofVerifier : public ProofVerifier {
+ public:
+ explicit RecordingProofVerifier(std::unique_ptr<ProofVerifier> verifier)
+ : verifier_(std::move(verifier)) {}
+
+ // ProofVerifier interface.
+ QuicAsyncStatus VerifyProof(
+ const std::string& hostname,
+ const uint16_t port,
+ const std::string& server_config,
+ QuicTransportVersion transport_version,
+ absl::string_view chlo_hash,
+ const std::vector<std::string>& certs,
+ const std::string& cert_sct,
+ const std::string& signature,
+ const ProofVerifyContext* context,
+ std::string* error_details,
+ std::unique_ptr<ProofVerifyDetails>* details,
+ std::unique_ptr<ProofVerifierCallback> callback) override {
+ QuicAsyncStatus process_certs_result = ProcessCerts(certs, cert_sct);
+ if (process_certs_result != QUIC_SUCCESS) {
+ return process_certs_result;
+ }
+
+ if (!verifier_) {
+ return QUIC_SUCCESS;
+ }
+
+ return verifier_->VerifyProof(hostname, port, server_config,
+ transport_version, chlo_hash, certs, cert_sct,
+ signature, context, error_details, details,
+ std::move(callback));
+ }
+
+ QuicAsyncStatus VerifyCertChain(
+ const std::string& /*hostname*/,
+ const uint16_t /*port*/,
+ const std::vector<std::string>& certs,
+ const std::string& /*ocsp_response*/,
+ const std::string& cert_sct,
+ const ProofVerifyContext* /*context*/,
+ std::string* /*error_details*/,
+ std::unique_ptr<ProofVerifyDetails>* /*details*/,
+ uint8_t* /*out_alert*/,
+ std::unique_ptr<ProofVerifierCallback> /*callback*/) override {
+ return ProcessCerts(certs, cert_sct);
+ }
+
+ std::unique_ptr<ProofVerifyContext> CreateDefaultContext() override {
+ return verifier_ != nullptr ? verifier_->CreateDefaultContext() : nullptr;
+ }
+
+ const std::string& common_name() const { return common_name_; }
+
+ const std::string& cert_sct() const { return cert_sct_; }
+
+ private:
+ QuicAsyncStatus ProcessCerts(const std::vector<std::string>& certs,
+ const std::string& cert_sct) {
+ common_name_.clear();
+ if (certs.empty()) {
+ return QUIC_FAILURE;
+ }
+
+ // Parse the cert into an X509 structure.
+ const uint8_t* data;
+ data = reinterpret_cast<const uint8_t*>(certs[0].data());
+ bssl::UniquePtr<X509> cert(d2i_X509(nullptr, &data, certs[0].size()));
+ if (!cert.get()) {
+ return QUIC_FAILURE;
+ }
+
+ // Extract the CN field
+ X509_NAME* subject = X509_get_subject_name(cert.get());
+ const int index = X509_NAME_get_index_by_NID(subject, NID_commonName, -1);
+ if (index < 0) {
+ return QUIC_FAILURE;
+ }
+ ASN1_STRING* name_data =
+ X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject, index));
+ if (name_data == nullptr) {
+ return QUIC_FAILURE;
+ }
+
+ // Convert the CN to UTF8, in case the cert represents it in a different
+ // format.
+ unsigned char* buf = nullptr;
+ const int len = ASN1_STRING_to_UTF8(&buf, name_data);
+ if (len <= 0) {
+ return QUIC_FAILURE;
+ }
+ bssl::UniquePtr<unsigned char> deleter(buf);
+
+ common_name_.assign(reinterpret_cast<const char*>(buf), len);
+ cert_sct_ = cert_sct;
+ return QUIC_SUCCESS;
+ }
+
+ std::unique_ptr<ProofVerifier> verifier_;
+ std::string common_name_;
+ std::string cert_sct_;
+};
+} // namespace
+
+class MockableQuicClientEpollNetworkHelper
+ : public QuicClientEpollNetworkHelper {
+ public:
+ using QuicClientEpollNetworkHelper::QuicClientEpollNetworkHelper;
+ ~MockableQuicClientEpollNetworkHelper() override = default;
+
+ void ProcessPacket(const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ const QuicReceivedPacket& packet) override {
+ QuicClientEpollNetworkHelper::ProcessPacket(self_address, peer_address,
+ packet);
+ if (track_last_incoming_packet_) {
+ last_incoming_packet_ = packet.Clone();
+ }
+ }
+
+ QuicPacketWriter* CreateQuicPacketWriter() override {
+ QuicPacketWriter* writer =
+ QuicClientEpollNetworkHelper::CreateQuicPacketWriter();
+ if (!test_writer_) {
+ return writer;
+ }
+ test_writer_->set_writer(writer);
+ return test_writer_;
+ }
+
+ const QuicReceivedPacket* last_incoming_packet() {
+ return last_incoming_packet_.get();
+ }
+
+ void set_track_last_incoming_packet(bool track) {
+ track_last_incoming_packet_ = track;
+ }
+
+ void UseWriter(QuicPacketWriterWrapper* writer) {
+ QUICHE_CHECK(test_writer_ == nullptr);
+ test_writer_ = writer;
+ }
+
+ void set_peer_address(const QuicSocketAddress& address) {
+ QUICHE_CHECK(test_writer_ != nullptr);
+ test_writer_->set_peer_address(address);
+ }
+
+ private:
+ QuicPacketWriterWrapper* test_writer_ = nullptr;
+ // The last incoming packet, iff |track_last_incoming_packet_| is true.
+ std::unique_ptr<QuicReceivedPacket> last_incoming_packet_;
+ // If true, copy each packet from ProcessPacket into |last_incoming_packet_|
+ bool track_last_incoming_packet_ = false;
+};
+
+MockableQuicClient::MockableQuicClient(
+ QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server)
+ : MockableQuicClient(server_address,
+ server_id,
+ QuicConfig(),
+ supported_versions,
+ epoll_server) {}
+
+MockableQuicClient::MockableQuicClient(
+ QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server)
+ : MockableQuicClient(server_address,
+ server_id,
+ config,
+ supported_versions,
+ epoll_server,
+ nullptr) {}
+
+MockableQuicClient::MockableQuicClient(
+ QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server,
+ std::unique_ptr<ProofVerifier> proof_verifier)
+ : MockableQuicClient(server_address,
+ server_id,
+ config,
+ supported_versions,
+ epoll_server,
+ std::move(proof_verifier),
+ nullptr) {}
+
+MockableQuicClient::MockableQuicClient(
+ QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server,
+ std::unique_ptr<ProofVerifier> proof_verifier,
+ std::unique_ptr<SessionCache> session_cache)
+ : QuicClient(
+ server_address,
+ server_id,
+ supported_versions,
+ config,
+ epoll_server,
+ std::make_unique<MockableQuicClientEpollNetworkHelper>(epoll_server,
+ this),
+ std::make_unique<RecordingProofVerifier>(std::move(proof_verifier)),
+ std::move(session_cache)),
+ override_server_connection_id_(EmptyQuicConnectionId()),
+ server_connection_id_overridden_(false),
+ override_client_connection_id_(EmptyQuicConnectionId()),
+ client_connection_id_overridden_(false) {}
+
+MockableQuicClient::~MockableQuicClient() {
+ if (connected()) {
+ Disconnect();
+ }
+}
+
+MockableQuicClientEpollNetworkHelper*
+MockableQuicClient::mockable_network_helper() {
+ return static_cast<MockableQuicClientEpollNetworkHelper*>(
+ epoll_network_helper());
+}
+
+const MockableQuicClientEpollNetworkHelper*
+MockableQuicClient::mockable_network_helper() const {
+ return static_cast<const MockableQuicClientEpollNetworkHelper*>(
+ epoll_network_helper());
+}
+
+QuicConnectionId MockableQuicClient::GenerateNewConnectionId() {
+ if (server_connection_id_overridden_) {
+ return override_server_connection_id_;
+ }
+ if (override_server_connection_id_length_ >= 0) {
+ return QuicUtils::CreateRandomConnectionId(
+ override_server_connection_id_length_);
+ }
+ return QuicClient::GenerateNewConnectionId();
+}
+
+void MockableQuicClient::UseConnectionId(
+ QuicConnectionId server_connection_id) {
+ server_connection_id_overridden_ = true;
+ override_server_connection_id_ = server_connection_id;
+}
+
+void MockableQuicClient::UseConnectionIdLength(
+ int server_connection_id_length) {
+ override_server_connection_id_length_ = server_connection_id_length;
+}
+
+QuicConnectionId MockableQuicClient::GetClientConnectionId() {
+ if (client_connection_id_overridden_) {
+ return override_client_connection_id_;
+ }
+ if (override_client_connection_id_length_ >= 0) {
+ return QuicUtils::CreateRandomConnectionId(
+ override_client_connection_id_length_);
+ }
+ return QuicClient::GetClientConnectionId();
+}
+
+void MockableQuicClient::UseClientConnectionId(
+ QuicConnectionId client_connection_id) {
+ client_connection_id_overridden_ = true;
+ override_client_connection_id_ = client_connection_id;
+}
+
+void MockableQuicClient::UseClientConnectionIdLength(
+ int client_connection_id_length) {
+ override_client_connection_id_length_ = client_connection_id_length;
+}
+
+void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
+ mockable_network_helper()->UseWriter(writer);
+}
+
+void MockableQuicClient::set_peer_address(const QuicSocketAddress& address) {
+ mockable_network_helper()->set_peer_address(address);
+ if (client_session() != nullptr) {
+ client_session()->AddKnownServerAddress(address);
+ }
+}
+
+const QuicReceivedPacket* MockableQuicClient::last_incoming_packet() {
+ return mockable_network_helper()->last_incoming_packet();
+}
+
+void MockableQuicClient::set_track_last_incoming_packet(bool track) {
+ mockable_network_helper()->set_track_last_incoming_packet(track);
+}
+
+QuicTestClient::QuicTestClient(
+ QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const ParsedQuicVersionVector& supported_versions)
+ : QuicTestClient(server_address,
+ server_hostname,
+ QuicConfig(),
+ supported_versions) {}
+
+QuicTestClient::QuicTestClient(
+ QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions)
+ : client_(new MockableQuicClient(
+ server_address,
+ QuicServerId(server_hostname, server_address.port(), false),
+ config,
+ supported_versions,
+ &epoll_server_)) {
+ Initialize();
+}
+
+QuicTestClient::QuicTestClient(
+ QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ std::unique_ptr<ProofVerifier> proof_verifier)
+ : client_(new MockableQuicClient(
+ server_address,
+ QuicServerId(server_hostname, server_address.port(), false),
+ config,
+ supported_versions,
+ &epoll_server_,
+ std::move(proof_verifier))) {
+ Initialize();
+}
+
+QuicTestClient::QuicTestClient(
+ QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ std::unique_ptr<ProofVerifier> proof_verifier,
+ std::unique_ptr<SessionCache> session_cache)
+ : client_(new MockableQuicClient(
+ server_address,
+ QuicServerId(server_hostname, server_address.port(), false),
+ config,
+ supported_versions,
+ &epoll_server_,
+ std::move(proof_verifier),
+ std::move(session_cache))) {
+ Initialize();
+}
+
+QuicTestClient::QuicTestClient() = default;
+
+QuicTestClient::~QuicTestClient() {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ stream.second->set_visitor(nullptr);
+ }
+}
+
+void QuicTestClient::Initialize() {
+ priority_ = 3;
+ connect_attempted_ = false;
+ auto_reconnect_ = false;
+ buffer_body_ = true;
+ num_requests_ = 0;
+ num_responses_ = 0;
+ ClearPerConnectionState();
+ // As chrome will generally do this, we want it to be the default when it's
+ // not overridden.
+ if (!client_->config()->HasSetBytesForConnectionIdToSend()) {
+ client_->config()->SetBytesForConnectionIdToSend(0);
+ }
+}
+
+void QuicTestClient::SetUserAgentID(const std::string& user_agent_id) {
+ client_->SetUserAgentID(user_agent_id);
+}
+
+ssize_t QuicTestClient::SendRequest(const std::string& uri) {
+ spdy::SpdyHeaderBlock headers;
+ if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
+ return 0;
+ }
+ return SendMessage(headers, "");
+}
+
+ssize_t QuicTestClient::SendRequestAndRstTogether(const std::string& uri) {
+ spdy::SpdyHeaderBlock headers;
+ if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
+ return 0;
+ }
+
+ QuicSpdyClientSession* session = client()->client_session();
+ QuicConnection::ScopedPacketFlusher flusher(session->connection());
+ ssize_t ret = SendMessage(headers, "", /*fin=*/true, /*flush=*/false);
+
+ QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(
+ session->transport_version(), 0);
+ session->ResetStream(stream_id, QUIC_STREAM_CANCELLED);
+ return ret;
+}
+
+void QuicTestClient::SendRequestsAndWaitForResponses(
+ const std::vector<std::string>& url_list) {
+ for (const std::string& url : url_list) {
+ SendRequest(url);
+ }
+ while (client()->WaitForEvents()) {
+ }
+}
+
+ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
+ const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
+ if (headers) {
+ QuicClientPushPromiseIndex::TryHandle* handle;
+ QuicAsyncStatus rv =
+ client()->push_promise_index()->Try(*headers, this, &handle);
+ if (rv == QUIC_SUCCESS)
+ return 1;
+ if (rv == QUIC_PENDING) {
+ // May need to retry request if asynchronous rendezvous fails.
+ std::unique_ptr<spdy::SpdyHeaderBlock> new_headers(
+ new spdy::SpdyHeaderBlock(headers->Clone()));
+ push_promise_data_to_resend_ = std::make_unique<TestClientDataToResend>(
+ std::move(new_headers), body, fin, this, std::move(ack_listener));
+ return 1;
+ }
+ }
+
+ // Maybe it's better just to overload this. it's just that we need
+ // for the GetOrCreateStream function to call something else...which
+ // is icky and complicated, but maybe not worse than this.
+ QuicSpdyClientStream* stream = GetOrCreateStream();
+ if (stream == nullptr) {
+ return 0;
+ }
+ QuicSpdyStreamPeer::set_ack_listener(stream, ack_listener);
+
+ ssize_t ret = 0;
+ if (headers != nullptr) {
+ spdy::SpdyHeaderBlock spdy_headers(headers->Clone());
+ if (spdy_headers[":authority"].as_string().empty()) {
+ spdy_headers[":authority"] = client_->server_id().host();
+ }
+ ret = stream->SendRequest(std::move(spdy_headers), body, fin);
+ ++num_requests_;
+ } else {
+ stream->WriteOrBufferBody(std::string(body), fin);
+ ret = body.length();
+ }
+ return ret;
+}
+
+ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body) {
+ return SendMessage(headers, body, /*fin=*/true);
+}
+
+ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body,
+ bool fin) {
+ return SendMessage(headers, body, fin, /*flush=*/true);
+}
+
+ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body,
+ bool fin,
+ bool flush) {
+ // Always force creation of a stream for SendMessage.
+ latest_created_stream_ = nullptr;
+
+ ssize_t ret = GetOrCreateStreamAndSendRequest(&headers, body, fin, nullptr);
+
+ if (flush) {
+ WaitForWriteToFlush();
+ }
+ return ret;
+}
+
+ssize_t QuicTestClient::SendData(const std::string& data, bool last_data) {
+ return SendData(data, last_data, nullptr);
+}
+
+ssize_t QuicTestClient::SendData(
+ const std::string& data, bool last_data,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
+ return GetOrCreateStreamAndSendRequest(nullptr, absl::string_view(data),
+ last_data, std::move(ack_listener));
+}
+
+bool QuicTestClient::response_complete() const {
+ return response_complete_;
+}
+
+int64_t QuicTestClient::response_body_size() const {
+ return response_body_size_;
+}
+
+bool QuicTestClient::buffer_body() const {
+ return buffer_body_;
+}
+
+void QuicTestClient::set_buffer_body(bool buffer_body) {
+ buffer_body_ = buffer_body;
+}
+
+const std::string& QuicTestClient::response_body() const {
+ return response_;
+}
+
+std::string QuicTestClient::SendCustomSynchronousRequest(
+ const spdy::SpdyHeaderBlock& headers,
+ const std::string& body) {
+ // Clear connection state here and only track this synchronous request.
+ ClearPerConnectionState();
+ if (SendMessage(headers, body) == 0) {
+ QUIC_DLOG(ERROR) << "Failed the request for: " << headers.DebugString();
+ // Set the response_ explicitly. Otherwise response_ will contain the
+ // response from the previously successful request.
+ response_ = "";
+ } else {
+ WaitForResponse();
+ }
+ return response_;
+}
+
+std::string QuicTestClient::SendSynchronousRequest(const std::string& uri) {
+ spdy::SpdyHeaderBlock headers;
+ if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
+ return "";
+ }
+ return SendCustomSynchronousRequest(headers, "");
+}
+
+void QuicTestClient::SendConnectivityProbing() {
+ QuicConnection* connection = client()->client_session()->connection();
+ connection->SendConnectivityProbingPacket(connection->writer(),
+ connection->peer_address());
+}
+
+void QuicTestClient::SetLatestCreatedStream(QuicSpdyClientStream* stream) {
+ latest_created_stream_ = stream;
+ if (latest_created_stream_ != nullptr) {
+ open_streams_[stream->id()] = stream;
+ stream->set_visitor(this);
+ }
+}
+
+QuicSpdyClientStream* QuicTestClient::GetOrCreateStream() {
+ if (!connect_attempted_ || auto_reconnect_) {
+ if (!connected()) {
+ Connect();
+ }
+ if (!connected()) {
+ return nullptr;
+ }
+ }
+ if (open_streams_.empty()) {
+ ClearPerConnectionState();
+ }
+ if (!latest_created_stream_) {
+ SetLatestCreatedStream(client_->CreateClientStream());
+ if (latest_created_stream_) {
+ latest_created_stream_->SetPriority(
+ spdy::SpdyStreamPrecedence(priority_));
+ }
+ }
+
+ return latest_created_stream_;
+}
+
+QuicErrorCode QuicTestClient::connection_error() const {
+ return client()->connection_error();
+}
+
+const std::string& QuicTestClient::cert_common_name() const {
+ return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
+ ->common_name();
+}
+
+const std::string& QuicTestClient::cert_sct() const {
+ return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
+ ->cert_sct();
+}
+
+const QuicTagValueMap& QuicTestClient::GetServerConfig() const {
+ QuicCryptoClientConfig* config = client_->crypto_config();
+ const QuicCryptoClientConfig::CachedState* state =
+ config->LookupOrCreate(client_->server_id());
+ const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
+ return handshake_msg->tag_value_map();
+}
+
+bool QuicTestClient::connected() const {
+ return client_->connected();
+}
+
+void QuicTestClient::Connect() {
+ if (connected()) {
+ QUIC_BUG(quic_bug_10133_1) << "Cannot connect already-connected client";
+ return;
+ }
+ if (!connect_attempted_) {
+ client_->Initialize();
+ }
+
+ // If we've been asked to override SNI, set it now
+ if (override_sni_set_) {
+ client_->set_server_id(
+ QuicServerId(override_sni_, address().port(), false));
+ }
+
+ client_->Connect();
+ connect_attempted_ = true;
+}
+
+void QuicTestClient::ResetConnection() {
+ Disconnect();
+ Connect();
+}
+
+void QuicTestClient::Disconnect() {
+ ClearPerConnectionState();
+ if (client_->initialized()) {
+ client_->Disconnect();
+ }
+ connect_attempted_ = false;
+}
+
+QuicSocketAddress QuicTestClient::local_address() const {
+ return client_->network_helper()->GetLatestClientAddress();
+}
+
+void QuicTestClient::ClearPerRequestState() {
+ stream_error_ = QUIC_STREAM_NO_ERROR;
+ response_ = "";
+ response_complete_ = false;
+ response_headers_complete_ = false;
+ preliminary_headers_.clear();
+ response_headers_.clear();
+ response_trailers_.clear();
+ bytes_read_ = 0;
+ bytes_written_ = 0;
+ response_body_size_ = 0;
+}
+
+bool QuicTestClient::HaveActiveStream() {
+ return push_promise_data_to_resend_.get() || !open_streams_.empty();
+}
+
+bool QuicTestClient::WaitUntil(int timeout_ms, std::function<bool()> trigger) {
+ int64_t timeout_us = timeout_ms * kNumMicrosPerMilli;
+ int64_t old_timeout_us = epoll_server()->timeout_in_us_for_test();
+ if (timeout_us > 0) {
+ epoll_server()->set_timeout_in_us(timeout_us);
+ }
+ const QuicClock* clock =
+ QuicConnectionPeer::GetHelper(client()->session()->connection())
+ ->GetClock();
+ QuicTime end_waiting_time =
+ clock->Now() + QuicTime::Delta::FromMicroseconds(timeout_us);
+ while (HaveActiveStream() && !(trigger && trigger()) &&
+ (timeout_us < 0 || clock->Now() < end_waiting_time)) {
+ client_->WaitForEvents();
+ }
+ ReadNextResponse();
+ if (timeout_us > 0) {
+ epoll_server()->set_timeout_in_us(old_timeout_us);
+ }
+ if (trigger && !trigger()) {
+ QUIC_VLOG(1) << "Client WaitUntil returning with trigger returning false.";
+ return false;
+ }
+ return true;
+}
+
+ssize_t QuicTestClient::Send(absl::string_view data) {
+ return SendData(std::string(data), false);
+}
+
+bool QuicTestClient::response_headers_complete() const {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ if (stream.second->headers_decompressed()) {
+ return true;
+ }
+ }
+ return response_headers_complete_;
+}
+
+const spdy::SpdyHeaderBlock* QuicTestClient::response_headers() const {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ if (stream.second->headers_decompressed()) {
+ response_headers_ = stream.second->response_headers().Clone();
+ break;
+ }
+ }
+ return &response_headers_;
+}
+
+const spdy::SpdyHeaderBlock* QuicTestClient::preliminary_headers() const {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ size_t bytes_read =
+ stream.second->stream_bytes_read() + stream.second->header_bytes_read();
+ if (bytes_read > 0) {
+ preliminary_headers_ = stream.second->preliminary_headers().Clone();
+ break;
+ }
+ }
+ return &preliminary_headers_;
+}
+
+const spdy::SpdyHeaderBlock& QuicTestClient::response_trailers() const {
+ return response_trailers_;
+}
+
+int64_t QuicTestClient::response_size() const {
+ return bytes_read();
+}
+
+size_t QuicTestClient::bytes_read() const {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ size_t bytes_read = stream.second->total_body_bytes_read() +
+ stream.second->header_bytes_read();
+ if (bytes_read > 0) {
+ return bytes_read;
+ }
+ }
+ return bytes_read_;
+}
+
+size_t QuicTestClient::bytes_written() const {
+ for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
+ size_t bytes_written = stream.second->stream_bytes_written() +
+ stream.second->header_bytes_written();
+ if (bytes_written > 0) {
+ return bytes_written;
+ }
+ }
+ return bytes_written_;
+}
+
+void QuicTestClient::OnClose(QuicSpdyStream* stream) {
+ if (stream == nullptr) {
+ return;
+ }
+ // Always close the stream, regardless of whether it was the last stream
+ // written.
+ client()->OnClose(stream);
+ ++num_responses_;
+ if (open_streams_.find(stream->id()) == open_streams_.end()) {
+ return;
+ }
+ if (latest_created_stream_ == stream) {
+ latest_created_stream_ = nullptr;
+ }
+ QuicSpdyClientStream* client_stream =
+ static_cast<QuicSpdyClientStream*>(stream);
+ QuicStreamId id = client_stream->id();
+ closed_stream_states_.insert(std::make_pair(
+ id,
+ PerStreamState(
+ // Set response_complete to true iff stream is closed while connected.
+ client_stream->stream_error(), connected(),
+ client_stream->headers_decompressed(),
+ client_stream->response_headers(),
+ client_stream->preliminary_headers(),
+ (buffer_body() ? client_stream->data() : ""),
+ client_stream->received_trailers(),
+ // Use NumBytesConsumed to avoid counting retransmitted stream frames.
+ client_stream->total_body_bytes_read() +
+ client_stream->header_bytes_read(),
+ client_stream->stream_bytes_written() +
+ client_stream->header_bytes_written(),
+ client_stream->data().size())));
+ open_streams_.erase(id);
+}
+
+bool QuicTestClient::CheckVary(
+ const spdy::SpdyHeaderBlock& /*client_request*/,
+ const spdy::SpdyHeaderBlock& /*promise_request*/,
+ const spdy::SpdyHeaderBlock& /*promise_response*/) {
+ return true;
+}
+
+void QuicTestClient::OnRendezvousResult(QuicSpdyStream* stream) {
+ std::unique_ptr<TestClientDataToResend> data_to_resend =
+ std::move(push_promise_data_to_resend_);
+ SetLatestCreatedStream(static_cast<QuicSpdyClientStream*>(stream));
+ if (stream) {
+ stream->OnBodyAvailable();
+ } else if (data_to_resend) {
+ data_to_resend->Resend();
+ }
+}
+
+void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
+ client_->UseWriter(writer);
+}
+
+void QuicTestClient::UseConnectionId(QuicConnectionId server_connection_id) {
+ QUICHE_DCHECK(!connected());
+ client_->UseConnectionId(server_connection_id);
+}
+
+void QuicTestClient::UseConnectionIdLength(int server_connection_id_length) {
+ QUICHE_DCHECK(!connected());
+ client_->UseConnectionIdLength(server_connection_id_length);
+}
+
+void QuicTestClient::UseClientConnectionId(
+ QuicConnectionId client_connection_id) {
+ QUICHE_DCHECK(!connected());
+ client_->UseClientConnectionId(client_connection_id);
+}
+
+void QuicTestClient::UseClientConnectionIdLength(
+ int client_connection_id_length) {
+ QUICHE_DCHECK(!connected());
+ client_->UseClientConnectionIdLength(client_connection_id_length);
+}
+
+bool QuicTestClient::MigrateSocket(const QuicIpAddress& new_host) {
+ return client_->MigrateSocket(new_host);
+}
+
+bool QuicTestClient::MigrateSocketWithSpecifiedPort(
+ const QuicIpAddress& new_host,
+ int port) {
+ client_->set_local_port(port);
+ return client_->MigrateSocket(new_host);
+}
+
+QuicIpAddress QuicTestClient::bind_to_address() const {
+ return client_->bind_to_address();
+}
+
+void QuicTestClient::set_bind_to_address(QuicIpAddress address) {
+ client_->set_bind_to_address(address);
+}
+
+const QuicSocketAddress& QuicTestClient::address() const {
+ return client_->server_address();
+}
+
+void QuicTestClient::WaitForWriteToFlush() {
+ while (connected() && client()->session()->HasDataToWrite()) {
+ client_->WaitForEvents();
+ }
+}
+
+QuicTestClient::TestClientDataToResend::TestClientDataToResend(
+ std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+ bool fin, QuicTestClient* test_client,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener)
+ : QuicClient::QuicDataToResend(std::move(headers), body, fin),
+ test_client_(test_client),
+ ack_listener_(std::move(ack_listener)) {}
+
+QuicTestClient::TestClientDataToResend::~TestClientDataToResend() = default;
+
+void QuicTestClient::TestClientDataToResend::Resend() {
+ test_client_->GetOrCreateStreamAndSendRequest(headers_.get(), body_, fin_,
+ ack_listener_);
+ headers_.reset();
+}
+
+QuicTestClient::PerStreamState::PerStreamState(const PerStreamState& other)
+ : stream_error(other.stream_error),
+ response_complete(other.response_complete),
+ response_headers_complete(other.response_headers_complete),
+ response_headers(other.response_headers.Clone()),
+ preliminary_headers(other.preliminary_headers.Clone()),
+ response(other.response),
+ response_trailers(other.response_trailers.Clone()),
+ bytes_read(other.bytes_read),
+ bytes_written(other.bytes_written),
+ response_body_size(other.response_body_size) {}
+
+QuicTestClient::PerStreamState::PerStreamState(
+ QuicRstStreamErrorCode stream_error,
+ bool response_complete,
+ bool response_headers_complete,
+ const spdy::SpdyHeaderBlock& response_headers,
+ const spdy::SpdyHeaderBlock& preliminary_headers,
+ const std::string& response,
+ const spdy::SpdyHeaderBlock& response_trailers,
+ uint64_t bytes_read,
+ uint64_t bytes_written,
+ int64_t response_body_size)
+ : stream_error(stream_error),
+ response_complete(response_complete),
+ response_headers_complete(response_headers_complete),
+ response_headers(response_headers.Clone()),
+ preliminary_headers(preliminary_headers.Clone()),
+ response(response),
+ response_trailers(response_trailers.Clone()),
+ bytes_read(bytes_read),
+ bytes_written(bytes_written),
+ response_body_size(response_body_size) {}
+
+QuicTestClient::PerStreamState::~PerStreamState() = default;
+
+bool QuicTestClient::PopulateHeaderBlockFromUrl(
+ const std::string& uri,
+ spdy::SpdyHeaderBlock* headers) {
+ std::string url;
+ if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://")) {
+ url = uri;
+ } else if (uri[0] == '/') {
+ url = "https://" + client_->server_id().host() + uri;
+ } else {
+ url = "https://" + uri;
+ }
+ return SpdyUtils::PopulateHeaderBlockFromUrl(url, headers);
+}
+
+void QuicTestClient::ReadNextResponse() {
+ if (closed_stream_states_.empty()) {
+ return;
+ }
+
+ PerStreamState state(closed_stream_states_.front().second);
+
+ stream_error_ = state.stream_error;
+ response_ = state.response;
+ response_complete_ = state.response_complete;
+ response_headers_complete_ = state.response_headers_complete;
+ preliminary_headers_ = state.preliminary_headers.Clone();
+ response_headers_ = state.response_headers.Clone();
+ response_trailers_ = state.response_trailers.Clone();
+ bytes_read_ = state.bytes_read;
+ bytes_written_ = state.bytes_written;
+ response_body_size_ = state.response_body_size;
+
+ closed_stream_states_.pop_front();
+}
+
+void QuicTestClient::ClearPerConnectionState() {
+ ClearPerRequestState();
+ open_streams_.clear();
+ closed_stream_states_.clear();
+ latest_created_stream_ = nullptr;
+}
+
+void QuicTestClient::WaitForDelayedAcks() {
+ // kWaitDuration is a period of time that is long enough for all delayed
+ // acks to be sent and received on the other end.
+ const QuicTime::Delta kWaitDuration =
+ 4 * QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
+
+ const QuicClock* clock = client()->client_session()->connection()->clock();
+
+ QuicTime wait_until = clock->ApproximateNow() + kWaitDuration;
+ while (connected() && clock->ApproximateNow() < wait_until) {
+ // This waits for up to 50 ms.
+ client()->WaitForEvents();
+ }
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
new file mode 100644
index 0000000..2878f9b
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_client.h
@@ -0,0 +1,448 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/proto/cached_network_parameters_proto.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packet_creator.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/platform/api/quic_epoll.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/tools/quic_client.h"
+#include "quiche/common/quiche_linked_hash_map.h"
+
+namespace quic {
+
+class ProofVerifier;
+class QuicPacketWriterWrapper;
+
+namespace test {
+
+class MockableQuicClientEpollNetworkHelper;
+
+// A quic client which allows mocking out reads and writes.
+class MockableQuicClient : public QuicClient {
+ public:
+ MockableQuicClient(QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server);
+
+ MockableQuicClient(QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server);
+
+ MockableQuicClient(QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server,
+ std::unique_ptr<ProofVerifier> proof_verifier);
+
+ MockableQuicClient(QuicSocketAddress server_address,
+ const QuicServerId& server_id,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicEpollServer* epoll_server,
+ std::unique_ptr<ProofVerifier> proof_verifier,
+ std::unique_ptr<SessionCache> session_cache);
+ MockableQuicClient(const MockableQuicClient&) = delete;
+ MockableQuicClient& operator=(const MockableQuicClient&) = delete;
+
+ ~MockableQuicClient() override;
+
+ QuicConnectionId GenerateNewConnectionId() override;
+ void UseConnectionId(QuicConnectionId server_connection_id);
+ void UseConnectionIdLength(int server_connection_id_length);
+ QuicConnectionId GetClientConnectionId() override;
+ void UseClientConnectionId(QuicConnectionId client_connection_id);
+ void UseClientConnectionIdLength(int client_connection_id_length);
+
+ void UseWriter(QuicPacketWriterWrapper* writer);
+ void set_peer_address(const QuicSocketAddress& address);
+ // The last incoming packet, iff |track_last_incoming_packet| is true.
+ const QuicReceivedPacket* last_incoming_packet();
+ // If true, copy each packet from ProcessPacket into |last_incoming_packet|
+ void set_track_last_incoming_packet(bool track);
+
+ // Casts the network helper to a MockableQuicClientEpollNetworkHelper.
+ MockableQuicClientEpollNetworkHelper* mockable_network_helper();
+ const MockableQuicClientEpollNetworkHelper* mockable_network_helper() const;
+
+ private:
+ // Server connection ID to use, if server_connection_id_overridden_
+ QuicConnectionId override_server_connection_id_;
+ bool server_connection_id_overridden_;
+ int override_server_connection_id_length_ = -1;
+ // Client connection ID to use, if client_connection_id_overridden_
+ QuicConnectionId override_client_connection_id_;
+ bool client_connection_id_overridden_;
+ int override_client_connection_id_length_ = -1;
+ CachedNetworkParameters cached_network_paramaters_;
+};
+
+// A toy QUIC client used for testing.
+class QuicTestClient : public QuicSpdyStream::Visitor,
+ public QuicClientPushPromiseIndex::Delegate {
+ public:
+ QuicTestClient(QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const ParsedQuicVersionVector& supported_versions);
+ QuicTestClient(QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions);
+ QuicTestClient(QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ std::unique_ptr<ProofVerifier> proof_verifier);
+ QuicTestClient(QuicSocketAddress server_address,
+ const std::string& server_hostname,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ std::unique_ptr<ProofVerifier> proof_verifier,
+ std::unique_ptr<SessionCache> session_cache);
+
+ ~QuicTestClient() override;
+
+ // Sets the |user_agent_id| of the |client_|.
+ void SetUserAgentID(const std::string& user_agent_id);
+
+ // Wraps data in a quic packet and sends it.
+ ssize_t SendData(const std::string& data, bool last_data);
+ // As above, but |delegate| will be notified when |data| is ACKed.
+ ssize_t SendData(
+ const std::string& data, bool last_data,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
+
+ // Clears any outstanding state and sends a simple GET of 'uri' to the
+ // server. Returns 0 if the request failed and no bytes were written.
+ ssize_t SendRequest(const std::string& uri);
+ // Send a request R and a RST_FRAME which resets R, in the same packet.
+ ssize_t SendRequestAndRstTogether(const std::string& uri);
+ // Sends requests for all the urls and waits for the responses. To process
+ // the individual responses as they are returned, the caller should use the
+ // set the response_listener on the client().
+ void SendRequestsAndWaitForResponses(
+ const std::vector<std::string>& url_list);
+ // Sends a request containing |headers| and |body| and returns the number of
+ // bytes sent (the size of the serialized request headers and body).
+ ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body);
+ // Sends a request containing |headers| and |body| with the fin bit set to
+ // |fin| and returns the number of bytes sent (the size of the serialized
+ // request headers and body).
+ ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body,
+ bool fin);
+ // Sends a request containing |headers| and |body| with the fin bit set to
+ // |fin| and returns the number of bytes sent (the size of the serialized
+ // request headers and body). If |flush| is true, will wait for the message to
+ // be flushed before returning.
+ ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+ absl::string_view body,
+ bool fin,
+ bool flush);
+ // Sends a request containing |headers| and |body|, waits for the response,
+ // and returns the response body.
+ std::string SendCustomSynchronousRequest(const spdy::SpdyHeaderBlock& headers,
+ const std::string& body);
+ // Sends a GET request for |uri|, waits for the response, and returns the
+ // response body.
+ std::string SendSynchronousRequest(const std::string& uri);
+ void SendConnectivityProbing();
+ void Connect();
+ void ResetConnection();
+ void Disconnect();
+ QuicSocketAddress local_address() const;
+ void ClearPerRequestState();
+ bool WaitUntil(int timeout_ms, std::function<bool()> trigger);
+ ssize_t Send(absl::string_view data);
+ bool connected() const;
+ bool buffer_body() const;
+ void set_buffer_body(bool buffer_body);
+
+ // Getters for stream state. Please note, these getters are divided into two
+ // groups. 1) returns state which only get updated once a complete response
+ // is received. 2) returns state of the oldest active stream which have
+ // received partial response (if any).
+ // Group 1.
+ const spdy::SpdyHeaderBlock& response_trailers() const;
+ bool response_complete() const;
+ int64_t response_body_size() const;
+ const std::string& response_body() const;
+ // Group 2.
+ bool response_headers_complete() const;
+ const spdy::SpdyHeaderBlock* response_headers() const;
+ const spdy::SpdyHeaderBlock* preliminary_headers() const;
+ int64_t response_size() const;
+ size_t bytes_read() const;
+ size_t bytes_written() const;
+
+ // Returns once at least one complete response or a connection close has been
+ // received from the server. If responses are received for multiple (say 2)
+ // streams, next WaitForResponse will return immediately.
+ void WaitForResponse() { WaitForResponseForMs(-1); }
+
+ // Returns once some data is received on any open streams or at least one
+ // complete response is received from the server.
+ void WaitForInitialResponse() { WaitForInitialResponseForMs(-1); }
+
+ // Returns once at least one complete response or a connection close has been
+ // received from the server, or once the timeout expires.
+ // Passing in a timeout value of -1 disables the timeout. If multiple
+ // responses are received while the client is waiting, subsequent calls to
+ // this function will return immediately.
+ void WaitForResponseForMs(int timeout_ms) {
+ WaitUntil(timeout_ms, [this]() { return !closed_stream_states_.empty(); });
+ if (response_complete()) {
+ QUIC_VLOG(1) << "Client received response:"
+ << response_headers()->DebugString() << response_body();
+ }
+ }
+
+ // Returns once some data is received on any open streams or at least one
+ // complete response is received from the server, or once the timeout
+ // expires. -1 means no timeout.
+ void WaitForInitialResponseForMs(int timeout_ms) {
+ WaitUntil(timeout_ms, [this]() { return response_size() != 0; });
+ }
+
+ // Migrate local address to <|new_host|, a random port>.
+ // Return whether the migration succeeded.
+ bool MigrateSocket(const QuicIpAddress& new_host);
+ // Migrate local address to <|new_host|, |port|>.
+ // Return whether the migration succeeded.
+ bool MigrateSocketWithSpecifiedPort(const QuicIpAddress& new_host, int port);
+ QuicIpAddress bind_to_address() const;
+ void set_bind_to_address(QuicIpAddress address);
+ const QuicSocketAddress& address() const;
+
+ // From QuicSpdyStream::Visitor
+ void OnClose(QuicSpdyStream* stream) override;
+
+ // From QuicClientPushPromiseIndex::Delegate
+ bool CheckVary(const spdy::SpdyHeaderBlock& client_request,
+ const spdy::SpdyHeaderBlock& promise_request,
+ const spdy::SpdyHeaderBlock& promise_response) override;
+ void OnRendezvousResult(QuicSpdyStream*) override;
+
+ // Configures client_ to take ownership of and use the writer.
+ // Must be called before initial connect.
+ void UseWriter(QuicPacketWriterWrapper* writer);
+ // Configures client_ to use a specific server connection ID instead of a
+ // random one.
+ void UseConnectionId(QuicConnectionId server_connection_id);
+ // Configures client_ to use a specific server connection ID length instead
+ // of the default of kQuicDefaultConnectionIdLength.
+ void UseConnectionIdLength(int server_connection_id_length);
+ // Configures client_ to use a specific client connection ID instead of an
+ // empty one.
+ void UseClientConnectionId(QuicConnectionId client_connection_id);
+ // Configures client_ to use a specific client connection ID length instead
+ // of the default of zero.
+ void UseClientConnectionIdLength(int client_connection_id_length);
+
+ // Returns nullptr if the maximum number of streams have already been created.
+ QuicSpdyClientStream* GetOrCreateStream();
+
+ // Calls GetOrCreateStream(), sends the request on the stream, and
+ // stores the request in case it needs to be resent. If |headers| is
+ // null, only the body will be sent on the stream.
+ ssize_t GetOrCreateStreamAndSendRequest(
+ const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
+
+ QuicRstStreamErrorCode stream_error() { return stream_error_; }
+ QuicErrorCode connection_error() const;
+
+ MockableQuicClient* client() { return client_.get(); }
+ const MockableQuicClient* client() const { return client_.get(); }
+
+ // cert_common_name returns the common name value of the server's certificate,
+ // or the empty std::string if no certificate was presented.
+ const std::string& cert_common_name() const;
+
+ // cert_sct returns the signed timestamp of the server's certificate,
+ // or the empty std::string if no signed timestamp was presented.
+ const std::string& cert_sct() const;
+
+ // Get the server config map. Server config must exist.
+ const QuicTagValueMap& GetServerConfig() const;
+
+ void set_auto_reconnect(bool reconnect) { auto_reconnect_ = reconnect; }
+
+ void set_priority(spdy::SpdyPriority priority) { priority_ = priority; }
+
+ void WaitForWriteToFlush();
+
+ QuicEpollServer* epoll_server() { return &epoll_server_; }
+
+ size_t num_requests() const { return num_requests_; }
+
+ size_t num_responses() const { return num_responses_; }
+
+ void set_server_address(const QuicSocketAddress& server_address) {
+ client_->set_server_address(server_address);
+ }
+
+ void set_peer_address(const QuicSocketAddress& address) {
+ client_->set_peer_address(address);
+ }
+
+ // Explicitly set the SNI value for this client, overriding the default
+ // behavior which extracts the SNI value from the request URL.
+ void OverrideSni(const std::string& sni) {
+ override_sni_set_ = true;
+ override_sni_ = sni;
+ }
+
+ void Initialize();
+
+ void set_client(MockableQuicClient* client) { client_.reset(client); }
+
+ // Given |uri|, populates the fields in |headers| for a simple GET
+ // request. If |uri| is a relative URL, the QuicServerId will be
+ // use to specify the authority.
+ bool PopulateHeaderBlockFromUrl(const std::string& uri,
+ spdy::SpdyHeaderBlock* headers);
+
+ // Waits for a period of time that is long enough to receive all delayed acks
+ // sent by peer.
+ void WaitForDelayedAcks();
+
+ QuicSpdyClientStream* latest_created_stream() {
+ return latest_created_stream_;
+ }
+
+ protected:
+ QuicTestClient();
+ QuicTestClient(const QuicTestClient&) = delete;
+ QuicTestClient(const QuicTestClient&&) = delete;
+ QuicTestClient& operator=(const QuicTestClient&) = delete;
+ QuicTestClient& operator=(const QuicTestClient&&) = delete;
+
+ private:
+ class TestClientDataToResend : public QuicClient::QuicDataToResend {
+ public:
+ TestClientDataToResend(
+ std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+ bool fin, QuicTestClient* test_client,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
+
+ ~TestClientDataToResend() override;
+
+ void Resend() override;
+
+ protected:
+ QuicTestClient* test_client_;
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener_;
+ };
+
+ // PerStreamState of a stream is updated when it is closed.
+ struct PerStreamState {
+ PerStreamState(const PerStreamState& other);
+ PerStreamState(QuicRstStreamErrorCode stream_error,
+ bool response_complete,
+ bool response_headers_complete,
+ const spdy::SpdyHeaderBlock& response_headers,
+ const spdy::SpdyHeaderBlock& preliminary_headers,
+ const std::string& response,
+ const spdy::SpdyHeaderBlock& response_trailers,
+ uint64_t bytes_read,
+ uint64_t bytes_written,
+ int64_t response_body_size);
+ ~PerStreamState();
+
+ QuicRstStreamErrorCode stream_error;
+ bool response_complete;
+ bool response_headers_complete;
+ spdy::SpdyHeaderBlock response_headers;
+ spdy::SpdyHeaderBlock preliminary_headers;
+ std::string response;
+ spdy::SpdyHeaderBlock response_trailers;
+ uint64_t bytes_read;
+ uint64_t bytes_written;
+ int64_t response_body_size;
+ };
+
+ bool HaveActiveStream();
+
+ // Read oldest received response and remove it from closed_stream_states_.
+ void ReadNextResponse();
+
+ // Clear open_streams_, closed_stream_states_ and reset
+ // latest_created_stream_.
+ void ClearPerConnectionState();
+
+ // Update latest_created_stream_, add |stream| to open_streams_ and starts
+ // tracking its state.
+ void SetLatestCreatedStream(QuicSpdyClientStream* stream);
+
+ QuicEpollServer epoll_server_;
+ std::unique_ptr<MockableQuicClient> client_; // The actual client
+ QuicSpdyClientStream* latest_created_stream_;
+ std::map<QuicStreamId, QuicSpdyClientStream*> open_streams_;
+ // Received responses of closed streams.
+ quiche::QuicheLinkedHashMap<QuicStreamId, PerStreamState>
+ closed_stream_states_;
+
+ QuicRstStreamErrorCode stream_error_;
+
+ bool response_complete_;
+ bool response_headers_complete_;
+ mutable spdy::SpdyHeaderBlock preliminary_headers_;
+ mutable spdy::SpdyHeaderBlock response_headers_;
+
+ // Parsed response trailers (if present), copied from the stream in OnClose.
+ spdy::SpdyHeaderBlock response_trailers_;
+
+ spdy::SpdyPriority priority_;
+ std::string response_;
+ // bytes_read_ and bytes_written_ are updated only when stream_ is released;
+ // prefer bytes_read() and bytes_written() member functions.
+ uint64_t bytes_read_;
+ uint64_t bytes_written_;
+ // The number of HTTP body bytes received.
+ int64_t response_body_size_;
+ // True if we tried to connect already since the last call to Disconnect().
+ bool connect_attempted_;
+ // The client will auto-connect exactly once before sending data. If
+ // something causes a connection reset, it will not automatically reconnect
+ // unless auto_reconnect_ is true.
+ bool auto_reconnect_;
+ // Should we buffer the response body? Defaults to true.
+ bool buffer_body_;
+ // For async push promise rendezvous, validation may fail in which
+ // case the request should be retried.
+ std::unique_ptr<TestClientDataToResend> push_promise_data_to_resend_;
+ // Number of requests/responses this client has sent/received.
+ size_t num_requests_;
+ size_t num_responses_;
+
+ // If set, this value is used for the connection SNI, overriding the usual
+ // logic which extracts the SNI from the request URL.
+ bool override_sni_set_ = false;
+ std::string override_sni_;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
diff --git a/quiche/quic/test_tools/quic_test_server.cc b/quiche/quic/test_tools/quic_test_server.cc
new file mode 100644
index 0000000..b19afc6
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_server.cc
@@ -0,0 +1,272 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_test_server.h"
+
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_epoll_alarm_factory.h"
+#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/tools/quic_simple_crypto_server_stream_helper.h"
+#include "quiche/quic/tools/quic_simple_dispatcher.h"
+#include "quiche/quic/tools/quic_simple_server_session.h"
+
+namespace quic {
+
+namespace test {
+
+class CustomStreamSession : public QuicSimpleServerSession {
+ public:
+ CustomStreamSession(
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicConnection* connection,
+ QuicSession::Visitor* visitor,
+ QuicCryptoServerStreamBase::Helper* helper,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ QuicTestServer::StreamFactory* stream_factory,
+ QuicTestServer::CryptoStreamFactory* crypto_stream_factory,
+ QuicSimpleServerBackend* quic_simple_server_backend)
+ : QuicSimpleServerSession(config,
+ supported_versions,
+ connection,
+ visitor,
+ helper,
+ crypto_config,
+ compressed_certs_cache,
+ quic_simple_server_backend),
+ stream_factory_(stream_factory),
+ crypto_stream_factory_(crypto_stream_factory) {}
+
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override {
+ if (!ShouldCreateIncomingStream(id)) {
+ return nullptr;
+ }
+ if (stream_factory_) {
+ QuicSpdyStream* stream =
+ stream_factory_->CreateStream(id, this, server_backend());
+ ActivateStream(absl::WrapUnique(stream));
+ return stream;
+ }
+ return QuicSimpleServerSession::CreateIncomingStream(id);
+ }
+
+ std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache) override {
+ if (crypto_stream_factory_) {
+ return crypto_stream_factory_->CreateCryptoStream(crypto_config, this);
+ }
+ return QuicSimpleServerSession::CreateQuicCryptoServerStream(
+ crypto_config, compressed_certs_cache);
+ }
+
+ private:
+ QuicTestServer::StreamFactory* stream_factory_; // Not owned.
+ QuicTestServer::CryptoStreamFactory* crypto_stream_factory_; // Not owned.
+};
+
+class QuicTestDispatcher : public QuicSimpleDispatcher {
+ public:
+ QuicTestDispatcher(
+ const QuicConfig* config,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicVersionManager* version_manager,
+ std::unique_ptr<QuicConnectionHelperInterface> helper,
+ std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
+ std::unique_ptr<QuicAlarmFactory> alarm_factory,
+ QuicSimpleServerBackend* quic_simple_server_backend,
+ uint8_t expected_server_connection_id_length)
+ : QuicSimpleDispatcher(config,
+ crypto_config,
+ version_manager,
+ std::move(helper),
+ std::move(session_helper),
+ std::move(alarm_factory),
+ quic_simple_server_backend,
+ expected_server_connection_id_length),
+ session_factory_(nullptr),
+ stream_factory_(nullptr),
+ crypto_stream_factory_(nullptr) {}
+
+ std::unique_ptr<QuicSession> CreateQuicSession(
+ QuicConnectionId id, const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address, absl::string_view /*alpn*/,
+ const ParsedQuicVersion& version,
+ const ParsedClientHello& /*parsed_chlo*/) override {
+ QuicReaderMutexLock lock(&factory_lock_);
+ // The QuicServerSessionBase takes ownership of |connection| below.
+ QuicConnection* connection = new QuicConnection(
+ id, self_address, peer_address, helper(), alarm_factory(), writer(),
+ /* owns_writer= */ false, Perspective::IS_SERVER,
+ ParsedQuicVersionVector{version});
+
+ std::unique_ptr<QuicServerSessionBase> session;
+ if (session_factory_ == nullptr && stream_factory_ == nullptr &&
+ crypto_stream_factory_ == nullptr) {
+ session = std::make_unique<QuicSimpleServerSession>(
+ config(), GetSupportedVersions(), connection, this, session_helper(),
+ crypto_config(), compressed_certs_cache(), server_backend());
+ } else if (stream_factory_ != nullptr ||
+ crypto_stream_factory_ != nullptr) {
+ session = std::make_unique<CustomStreamSession>(
+ config(), GetSupportedVersions(), connection, this, session_helper(),
+ crypto_config(), compressed_certs_cache(), stream_factory_,
+ crypto_stream_factory_, server_backend());
+ } else {
+ session = session_factory_->CreateSession(
+ config(), connection, this, session_helper(), crypto_config(),
+ compressed_certs_cache(), server_backend());
+ }
+ if (VersionUsesHttp3(version.transport_version) &&
+ GetQuicReloadableFlag(quic_verify_request_headers_2)) {
+ QUICHE_DCHECK(session->allow_extended_connect());
+ // Do not allow extended CONNECT request if the backend doesn't support
+ // it.
+ session->set_allow_extended_connect(
+ server_backend()->SupportsExtendedConnect());
+ }
+ session->Initialize();
+ return session;
+ }
+
+ void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
+ QuicWriterMutexLock lock(&factory_lock_);
+ QUICHE_DCHECK(session_factory_ == nullptr);
+ QUICHE_DCHECK(stream_factory_ == nullptr);
+ QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
+ session_factory_ = factory;
+ }
+
+ void SetStreamFactory(QuicTestServer::StreamFactory* factory) {
+ QuicWriterMutexLock lock(&factory_lock_);
+ QUICHE_DCHECK(session_factory_ == nullptr);
+ QUICHE_DCHECK(stream_factory_ == nullptr);
+ stream_factory_ = factory;
+ }
+
+ void SetCryptoStreamFactory(QuicTestServer::CryptoStreamFactory* factory) {
+ QuicWriterMutexLock lock(&factory_lock_);
+ QUICHE_DCHECK(session_factory_ == nullptr);
+ QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
+ crypto_stream_factory_ = factory;
+ }
+
+ private:
+ QuicMutex factory_lock_;
+ QuicTestServer::SessionFactory* session_factory_; // Not owned.
+ QuicTestServer::StreamFactory* stream_factory_; // Not owned.
+ QuicTestServer::CryptoStreamFactory* crypto_stream_factory_; // Not owned.
+};
+
+QuicTestServer::QuicTestServer(
+ std::unique_ptr<ProofSource> proof_source,
+ QuicSimpleServerBackend* quic_simple_server_backend)
+ : QuicServer(std::move(proof_source), quic_simple_server_backend) {}
+
+QuicTestServer::QuicTestServer(
+ std::unique_ptr<ProofSource> proof_source,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicSimpleServerBackend* quic_simple_server_backend)
+ : QuicTestServer(std::move(proof_source),
+ config,
+ supported_versions,
+ quic_simple_server_backend,
+ kQuicDefaultConnectionIdLength) {}
+
+QuicTestServer::QuicTestServer(
+ std::unique_ptr<ProofSource> proof_source,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicSimpleServerBackend* quic_simple_server_backend,
+ uint8_t expected_server_connection_id_length)
+ : QuicServer(std::move(proof_source),
+ config,
+ QuicCryptoServerConfig::ConfigOptions(),
+ supported_versions,
+ quic_simple_server_backend,
+ expected_server_connection_id_length) {}
+
+QuicDispatcher* QuicTestServer::CreateQuicDispatcher() {
+ return new QuicTestDispatcher(
+ &config(), &crypto_config(), version_manager(),
+ std::make_unique<QuicEpollConnectionHelper>(epoll_server(),
+ QuicAllocator::BUFFER_POOL),
+ std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
+ new QuicSimpleCryptoServerStreamHelper()),
+ std::make_unique<QuicEpollAlarmFactory>(epoll_server()), server_backend(),
+ expected_server_connection_id_length());
+}
+
+void QuicTestServer::SetSessionFactory(SessionFactory* factory) {
+ QUICHE_DCHECK(dispatcher());
+ static_cast<QuicTestDispatcher*>(dispatcher())->SetSessionFactory(factory);
+}
+
+void QuicTestServer::SetSpdyStreamFactory(StreamFactory* factory) {
+ static_cast<QuicTestDispatcher*>(dispatcher())->SetStreamFactory(factory);
+}
+
+void QuicTestServer::SetCryptoStreamFactory(CryptoStreamFactory* factory) {
+ static_cast<QuicTestDispatcher*>(dispatcher())
+ ->SetCryptoStreamFactory(factory);
+}
+
+/////////////////////////// TEST SESSIONS ///////////////////////////////
+
+ImmediateGoAwaySession::ImmediateGoAwaySession(
+ const QuicConfig& config,
+ QuicConnection* connection,
+ QuicSession::Visitor* visitor,
+ QuicCryptoServerStreamBase::Helper* helper,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ QuicSimpleServerBackend* quic_simple_server_backend)
+ : QuicSimpleServerSession(config,
+ CurrentSupportedVersions(),
+ connection,
+ visitor,
+ helper,
+ crypto_config,
+ compressed_certs_cache,
+ quic_simple_server_backend) {}
+
+void ImmediateGoAwaySession::OnStreamFrame(const QuicStreamFrame& frame) {
+ if (VersionUsesHttp3(transport_version())) {
+ SendHttp3GoAway(QUIC_PEER_GOING_AWAY, "");
+ } else {
+ SendGoAway(QUIC_PEER_GOING_AWAY, "");
+ }
+ QuicSimpleServerSession::OnStreamFrame(frame);
+}
+
+void ImmediateGoAwaySession::OnCryptoFrame(const QuicCryptoFrame& frame) {
+ // In IETF QUIC, GOAWAY lives up in HTTP/3 layer. It's sent in a QUIC stream
+ // and requires encryption. Thus the sending is done in
+ // OnNewEncryptionKeyAvailable().
+ if (!VersionUsesHttp3(transport_version())) {
+ SendGoAway(QUIC_PEER_GOING_AWAY, "");
+ }
+ QuicSimpleServerSession::OnCryptoFrame(frame);
+}
+
+void ImmediateGoAwaySession::OnNewEncryptionKeyAvailable(
+ EncryptionLevel level,
+ std::unique_ptr<QuicEncrypter> encrypter) {
+ QuicSimpleServerSession::OnNewEncryptionKeyAvailable(level,
+ std::move(encrypter));
+ if (VersionUsesHttp3(transport_version())) {
+ if (IsEncryptionEstablished() && !goaway_sent()) {
+ SendHttp3GoAway(QUIC_PEER_GOING_AWAY, "");
+ }
+ }
+}
+
+} // namespace test
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_test_server.h b/quiche/quic/test_tools/quic_test_server.h
new file mode 100644
index 0000000..277dade
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_server.h
@@ -0,0 +1,121 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_SERVER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_SERVER_H_
+
+#include "quiche/quic/core/quic_dispatcher.h"
+#include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/tools/quic_server.h"
+#include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/quic/tools/quic_simple_server_session.h"
+#include "quiche/quic/tools/quic_simple_server_stream.h"
+
+namespace quic {
+
+namespace test {
+
+// A test server which enables easy creation of custom QuicServerSessions
+//
+// Eventually this may be extended to allow custom QuicConnections etc.
+class QuicTestServer : public QuicServer {
+ public:
+ // Factory for creating QuicServerSessions.
+ class SessionFactory {
+ public:
+ virtual ~SessionFactory() {}
+
+ // Returns a new session owned by the caller.
+ virtual std::unique_ptr<QuicServerSessionBase> CreateSession(
+ const QuicConfig& config,
+ QuicConnection* connection,
+ QuicSession::Visitor* visitor,
+ QuicCryptoServerStreamBase::Helper* helper,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ QuicSimpleServerBackend* quic_simple_server_backend) = 0;
+ };
+
+ // Factory for creating QuicSimpleServerStreams.
+ class StreamFactory {
+ public:
+ virtual ~StreamFactory() {}
+
+ // Returns a new stream owned by the caller.
+ virtual QuicSimpleServerStream* CreateStream(
+ QuicStreamId id,
+ QuicSpdySession* session,
+ QuicSimpleServerBackend* quic_simple_server_backend) = 0;
+
+ virtual QuicSimpleServerStream* CreateStream(
+ PendingStream* pending, QuicSpdySession* session,
+ QuicSimpleServerBackend* quic_simple_server_backend) = 0;
+ };
+
+ class CryptoStreamFactory {
+ public:
+ virtual ~CryptoStreamFactory() {}
+
+ // Returns a new QuicCryptoServerStreamBase owned by the caller
+ virtual std::unique_ptr<QuicCryptoServerStreamBase> CreateCryptoStream(
+ const QuicCryptoServerConfig* crypto_config,
+ QuicServerSessionBase* session) = 0;
+ };
+
+ QuicTestServer(std::unique_ptr<ProofSource> proof_source,
+ QuicSimpleServerBackend* quic_simple_server_backend);
+ QuicTestServer(std::unique_ptr<ProofSource> proof_source,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicSimpleServerBackend* quic_simple_server_backend);
+ QuicTestServer(std::unique_ptr<ProofSource> proof_source,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ QuicSimpleServerBackend* quic_simple_server_backend,
+ uint8_t expected_server_connection_id_length);
+
+ // Create a custom dispatcher which creates custom sessions.
+ QuicDispatcher* CreateQuicDispatcher() override;
+
+ // Sets a custom session factory, owned by the caller, for easy custom
+ // session logic. This is incompatible with setting a stream factory or a
+ // crypto stream factory.
+ void SetSessionFactory(SessionFactory* factory);
+
+ // Sets a custom stream factory, owned by the caller, for easy custom
+ // stream logic. This is incompatible with setting a session factory.
+ void SetSpdyStreamFactory(StreamFactory* factory);
+
+ // Sets a custom crypto stream factory, owned by the caller, for easy custom
+ // crypto logic. This is incompatible with setting a session factory.
+ void SetCryptoStreamFactory(CryptoStreamFactory* factory);
+};
+
+// Useful test sessions for the QuicTestServer.
+
+// Test session which sends a GOAWAY immedaitely on creation, before crypto
+// credentials have even been established.
+class ImmediateGoAwaySession : public QuicSimpleServerSession {
+ public:
+ ImmediateGoAwaySession(const QuicConfig& config,
+ QuicConnection* connection,
+ QuicSession::Visitor* visitor,
+ QuicCryptoServerStreamBase::Helper* helper,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ QuicSimpleServerBackend* quic_simple_server_backend);
+
+ // Override to send GoAway.
+ void OnStreamFrame(const QuicStreamFrame& frame) override;
+ void OnCryptoFrame(const QuicCryptoFrame& frame) override;
+ void OnNewEncryptionKeyAvailable(
+ EncryptionLevel level,
+ std::unique_ptr<QuicEncrypter> encrypter) override;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_SERVER_H_
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
new file mode 100644
index 0000000..336437b
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -0,0 +1,1618 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/strings/string_view.h"
+#include "third_party/boringssl/src/include/openssl/chacha.h"
+#include "third_party/boringssl/src/include/openssl/sha.h"
+#include "quiche/quic/core/crypto/crypto_framer.h"
+#include "quiche/quic/core/crypto/crypto_handshake.h"
+#include "quiche/quic/core/crypto/crypto_utils.h"
+#include "quiche/quic/core/crypto/null_decrypter.h"
+#include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/crypto/quic_decrypter.h"
+#include "quiche/quic/core/crypto/quic_encrypter.h"
+#include "quiche/quic/core/http/quic_spdy_client_session.h"
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packet_creator.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/core/quic_versions.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+#include "quiche/quic/test_tools/quic_config_peer.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_endian.h"
+#include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/spdy/core/spdy_frame_builder.h"
+
+using testing::_;
+using testing::Invoke;
+
+namespace quic {
+namespace test {
+
+QuicConnectionId TestConnectionId() {
+ // Chosen by fair dice roll.
+ // Guaranteed to be random.
+ return TestConnectionId(42);
+}
+
+QuicConnectionId TestConnectionId(uint64_t connection_number) {
+ const uint64_t connection_id64_net =
+ quiche::QuicheEndian::HostToNet64(connection_number);
+ return QuicConnectionId(reinterpret_cast<const char*>(&connection_id64_net),
+ sizeof(connection_id64_net));
+}
+
+QuicConnectionId TestConnectionIdNineBytesLong(uint64_t connection_number) {
+ const uint64_t connection_number_net =
+ quiche::QuicheEndian::HostToNet64(connection_number);
+ char connection_id_bytes[9] = {};
+ static_assert(
+ sizeof(connection_id_bytes) == 1 + sizeof(connection_number_net),
+ "bad lengths");
+ memcpy(connection_id_bytes + 1, &connection_number_net,
+ sizeof(connection_number_net));
+ return QuicConnectionId(connection_id_bytes, sizeof(connection_id_bytes));
+}
+
+uint64_t TestConnectionIdToUInt64(QuicConnectionId connection_id) {
+ QUICHE_DCHECK_EQ(connection_id.length(), kQuicDefaultConnectionIdLength);
+ uint64_t connection_id64_net = 0;
+ memcpy(&connection_id64_net, connection_id.data(),
+ std::min<size_t>(static_cast<size_t>(connection_id.length()),
+ sizeof(connection_id64_net)));
+ return quiche::QuicheEndian::NetToHost64(connection_id64_net);
+}
+
+std::vector<uint8_t> CreateStatelessResetTokenForTest() {
+ static constexpr uint8_t kStatelessResetTokenDataForTest[16] = {
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F};
+ return std::vector<uint8_t>(kStatelessResetTokenDataForTest,
+ kStatelessResetTokenDataForTest +
+ sizeof(kStatelessResetTokenDataForTest));
+}
+
+std::string TestHostname() { return "test.example.com"; }
+
+QuicServerId TestServerId() {
+ return QuicServerId(TestHostname(), kTestPort);
+}
+
+QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks) {
+ QUICHE_DCHECK_GT(ack_blocks.size(), 0u);
+
+ QuicAckFrame ack;
+ QuicPacketNumber end_of_previous_block(1);
+ for (const QuicAckBlock& block : ack_blocks) {
+ QUICHE_DCHECK_GE(block.start, end_of_previous_block);
+ QUICHE_DCHECK_GT(block.limit, block.start);
+ ack.packets.AddRange(block.start, block.limit);
+ end_of_previous_block = block.limit;
+ }
+
+ ack.largest_acked = ack.packets.Max();
+
+ return ack;
+}
+
+QuicAckFrame InitAckFrame(uint64_t largest_acked) {
+ return InitAckFrame(QuicPacketNumber(largest_acked));
+}
+
+QuicAckFrame InitAckFrame(QuicPacketNumber largest_acked) {
+ return InitAckFrame({{QuicPacketNumber(1), largest_acked + 1}});
+}
+
+QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks,
+ uint64_t least_unacked) {
+ QuicAckFrame ack;
+ ack.largest_acked = QuicPacketNumber(2 * num_ack_blocks + least_unacked);
+ // Add enough received packets to get num_ack_blocks ack blocks.
+ for (QuicPacketNumber i = QuicPacketNumber(2);
+ i < QuicPacketNumber(2 * num_ack_blocks + 1); i += 2) {
+ ack.packets.Add(i + least_unacked);
+ }
+ return ack;
+}
+
+QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size,
+ size_t max_num_gaps,
+ uint64_t largest_acked) {
+ QuicAckFrame ack;
+ ack.largest_acked = QuicPacketNumber(largest_acked);
+ ack.packets.Add(QuicPacketNumber(largest_acked));
+ for (size_t i = 0; i < max_num_gaps; ++i) {
+ if (largest_acked <= gap_size) {
+ break;
+ }
+ largest_acked -= gap_size;
+ ack.packets.Add(QuicPacketNumber(largest_acked));
+ }
+ return ack;
+}
+
+EncryptionLevel HeaderToEncryptionLevel(const QuicPacketHeader& header) {
+ if (header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
+ return ENCRYPTION_FORWARD_SECURE;
+ } else if (header.form == IETF_QUIC_LONG_HEADER_PACKET) {
+ if (header.long_packet_type == HANDSHAKE) {
+ return ENCRYPTION_HANDSHAKE;
+ } else if (header.long_packet_type == ZERO_RTT_PROTECTED) {
+ return ENCRYPTION_ZERO_RTT;
+ }
+ }
+ return ENCRYPTION_INITIAL;
+}
+
+std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
+ QuicFramer* framer,
+ const QuicPacketHeader& header,
+ const QuicFrames& frames) {
+ const size_t max_plaintext_size =
+ framer->GetMaxPlaintextSize(kMaxOutgoingPacketSize);
+ size_t packet_size = GetPacketHeaderSize(framer->transport_version(), header);
+ for (size_t i = 0; i < frames.size(); ++i) {
+ QUICHE_DCHECK_LE(packet_size, max_plaintext_size);
+ bool first_frame = i == 0;
+ bool last_frame = i == frames.size() - 1;
+ const size_t frame_size = framer->GetSerializedFrameLength(
+ frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
+ header.packet_number_length);
+ QUICHE_DCHECK(frame_size);
+ packet_size += frame_size;
+ }
+ return BuildUnsizedDataPacket(framer, header, frames, packet_size);
+}
+
+std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
+ QuicFramer* framer,
+ const QuicPacketHeader& header,
+ const QuicFrames& frames,
+ size_t packet_size) {
+ char* buffer = new char[packet_size];
+ EncryptionLevel level = HeaderToEncryptionLevel(header);
+ size_t length =
+ framer->BuildDataPacket(header, frames, buffer, packet_size, level);
+
+ if (length == 0) {
+ delete[] buffer;
+ return nullptr;
+ }
+ // Re-construct the data packet with data ownership.
+ return std::make_unique<QuicPacket>(
+ buffer, length, /* owns_buffer */ true,
+ GetIncludedDestinationConnectionIdLength(header),
+ GetIncludedSourceConnectionIdLength(header), header.version_flag,
+ header.nonce != nullptr, header.packet_number_length,
+ header.retry_token_length_length, header.retry_token.length(),
+ header.length_length);
+}
+
+std::string Sha1Hash(absl::string_view data) {
+ char buffer[SHA_DIGEST_LENGTH];
+ SHA1(reinterpret_cast<const uint8_t*>(data.data()), data.size(),
+ reinterpret_cast<uint8_t*>(buffer));
+ return std::string(buffer, ABSL_ARRAYSIZE(buffer));
+}
+
+bool ClearControlFrame(const QuicFrame& frame) {
+ DeleteFrame(&const_cast<QuicFrame&>(frame));
+ return true;
+}
+
+bool ClearControlFrameWithTransmissionType(const QuicFrame& frame,
+ TransmissionType /*type*/) {
+ return ClearControlFrame(frame);
+}
+
+uint64_t SimpleRandom::RandUint64() {
+ uint64_t result;
+ RandBytes(&result, sizeof(result));
+ return result;
+}
+
+void SimpleRandom::RandBytes(void* data, size_t len) {
+ uint8_t* data_bytes = reinterpret_cast<uint8_t*>(data);
+ while (len > 0) {
+ const size_t buffer_left = sizeof(buffer_) - buffer_offset_;
+ const size_t to_copy = std::min(buffer_left, len);
+ memcpy(data_bytes, buffer_ + buffer_offset_, to_copy);
+ data_bytes += to_copy;
+ buffer_offset_ += to_copy;
+ len -= to_copy;
+
+ if (buffer_offset_ == sizeof(buffer_)) {
+ FillBuffer();
+ }
+ }
+}
+
+void SimpleRandom::InsecureRandBytes(void* data, size_t len) {
+ RandBytes(data, len);
+}
+
+uint64_t SimpleRandom::InsecureRandUint64() {
+ return RandUint64();
+}
+
+void SimpleRandom::FillBuffer() {
+ uint8_t nonce[12];
+ memcpy(nonce, buffer_, sizeof(nonce));
+ CRYPTO_chacha_20(buffer_, buffer_, sizeof(buffer_), key_, nonce, 0);
+ buffer_offset_ = 0;
+}
+
+void SimpleRandom::set_seed(uint64_t seed) {
+ static_assert(sizeof(key_) == SHA256_DIGEST_LENGTH, "Key has to be 256 bits");
+ SHA256(reinterpret_cast<const uint8_t*>(&seed), sizeof(seed), key_);
+
+ memset(buffer_, 0, sizeof(buffer_));
+ FillBuffer();
+}
+
+MockFramerVisitor::MockFramerVisitor() {
+ // By default, we want to accept packets.
+ ON_CALL(*this, OnProtocolVersionMismatch(_))
+ .WillByDefault(testing::Return(false));
+
+ // By default, we want to accept packets.
+ ON_CALL(*this, OnUnauthenticatedHeader(_))
+ .WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
+ .WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnPacketHeader(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnStreamFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnCryptoFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnStopWaitingFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnPaddingFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnPingFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnRstStreamFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnConnectionCloseFrame(_))
+ .WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnStopSendingFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnPathChallengeFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnPathResponseFrame(_)).WillByDefault(testing::Return(true));
+
+ ON_CALL(*this, OnGoAwayFrame(_)).WillByDefault(testing::Return(true));
+ ON_CALL(*this, OnMaxStreamsFrame(_)).WillByDefault(testing::Return(true));
+ ON_CALL(*this, OnStreamsBlockedFrame(_)).WillByDefault(testing::Return(true));
+}
+
+MockFramerVisitor::~MockFramerVisitor() {}
+
+bool NoOpFramerVisitor::OnProtocolVersionMismatch(
+ ParsedQuicVersion /*version*/) {
+ return false;
+}
+
+bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
+ const QuicPacketHeader& /*header*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnUnauthenticatedHeader(
+ const QuicPacketHeader& /*header*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& /*header*/) {
+ return true;
+}
+
+void NoOpFramerVisitor::OnCoalescedPacket(
+ const QuicEncryptedPacket& /*packet*/) {}
+
+void NoOpFramerVisitor::OnUndecryptablePacket(
+ const QuicEncryptedPacket& /*packet*/,
+ EncryptionLevel /*decryption_level*/,
+ bool /*has_decryption_key*/) {}
+
+bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnAckFrameStart(QuicPacketNumber /*largest_acked*/,
+ QuicTime::Delta /*ack_delay_time*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnAckRange(QuicPacketNumber /*start*/,
+ QuicPacketNumber /*end*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnAckTimestamp(QuicPacketNumber /*packet_number*/,
+ QuicTime /*timestamp*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnAckFrameEnd(QuicPacketNumber /*start*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnStopWaitingFrame(
+ const QuicStopWaitingFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnConnectionCloseFrame(
+ const QuicConnectionCloseFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnNewConnectionIdFrame(
+ const QuicNewConnectionIdFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnRetireConnectionIdFrame(
+ const QuicRetireConnectionIdFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnStopSendingFrame(
+ const QuicStopSendingFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnPathChallengeFrame(
+ const QuicPathChallengeFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnPathResponseFrame(
+ const QuicPathResponseFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnMaxStreamsFrame(
+ const QuicMaxStreamsFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnStreamsBlockedFrame(
+ const QuicStreamsBlockedFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnWindowUpdateFrame(
+ const QuicWindowUpdateFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnMessageFrame(const QuicMessageFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnHandshakeDoneFrame(
+ const QuicHandshakeDoneFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::OnAckFrequencyFrame(
+ const QuicAckFrequencyFrame& /*frame*/) {
+ return true;
+}
+
+bool NoOpFramerVisitor::IsValidStatelessResetToken(
+ const StatelessResetToken& /*token*/) const {
+ return false;
+}
+
+MockQuicConnectionVisitor::MockQuicConnectionVisitor() {}
+
+MockQuicConnectionVisitor::~MockQuicConnectionVisitor() {}
+
+MockQuicConnectionHelper::MockQuicConnectionHelper() {}
+
+MockQuicConnectionHelper::~MockQuicConnectionHelper() {}
+
+const QuicClock* MockQuicConnectionHelper::GetClock() const {
+ return &clock_;
+}
+
+QuicRandom* MockQuicConnectionHelper::GetRandomGenerator() {
+ return &random_generator_;
+}
+
+QuicAlarm* MockAlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
+ return new MockAlarmFactory::TestAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+}
+
+QuicArenaScopedPtr<QuicAlarm> MockAlarmFactory::CreateAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+ QuicConnectionArena* arena) {
+ if (arena != nullptr) {
+ return arena->New<TestAlarm>(std::move(delegate));
+ } else {
+ return QuicArenaScopedPtr<TestAlarm>(new TestAlarm(std::move(delegate)));
+ }
+}
+
+quiche::QuicheBufferAllocator*
+MockQuicConnectionHelper::GetStreamSendBufferAllocator() {
+ return &buffer_allocator_;
+}
+
+void MockQuicConnectionHelper::AdvanceTime(QuicTime::Delta delta) {
+ clock_.AdvanceTime(delta);
+}
+
+MockQuicConnection::MockQuicConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective)
+ : MockQuicConnection(TestConnectionId(),
+ QuicSocketAddress(TestPeerIPAddress(), kTestPort),
+ helper,
+ alarm_factory,
+ perspective,
+ ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
+
+MockQuicConnection::MockQuicConnection(QuicSocketAddress address,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective)
+ : MockQuicConnection(TestConnectionId(),
+ address,
+ helper,
+ alarm_factory,
+ perspective,
+ ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
+
+MockQuicConnection::MockQuicConnection(QuicConnectionId connection_id,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective)
+ : MockQuicConnection(connection_id,
+ QuicSocketAddress(TestPeerIPAddress(), kTestPort),
+ helper,
+ alarm_factory,
+ perspective,
+ ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
+
+MockQuicConnection::MockQuicConnection(
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions)
+ : MockQuicConnection(TestConnectionId(),
+ QuicSocketAddress(TestPeerIPAddress(), kTestPort),
+ helper,
+ alarm_factory,
+ perspective,
+ supported_versions) {}
+
+MockQuicConnection::MockQuicConnection(
+ QuicConnectionId connection_id,
+ QuicSocketAddress initial_peer_address,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions)
+ : QuicConnection(
+ connection_id,
+ /*initial_self_address=*/QuicSocketAddress(QuicIpAddress::Any4(), 5),
+ initial_peer_address,
+ helper,
+ alarm_factory,
+ new testing::NiceMock<MockPacketWriter>(),
+ /* owns_writer= */ true,
+ perspective,
+ supported_versions) {
+ ON_CALL(*this, OnError(_))
+ .WillByDefault(
+ Invoke(this, &PacketSavingConnection::QuicConnection_OnError));
+ ON_CALL(*this, SendCryptoData(_, _, _))
+ .WillByDefault(
+ Invoke(this, &MockQuicConnection::QuicConnection_SendCryptoData));
+
+ SetSelfAddress(QuicSocketAddress(QuicIpAddress::Any4(), 5));
+}
+
+MockQuicConnection::~MockQuicConnection() {}
+
+void MockQuicConnection::AdvanceTime(QuicTime::Delta delta) {
+ static_cast<MockQuicConnectionHelper*>(helper())->AdvanceTime(delta);
+}
+
+bool MockQuicConnection::OnProtocolVersionMismatch(
+ ParsedQuicVersion /*version*/) {
+ return false;
+}
+
+PacketSavingConnection::PacketSavingConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective)
+ : MockQuicConnection(helper, alarm_factory, perspective) {}
+
+PacketSavingConnection::PacketSavingConnection(
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions)
+ : MockQuicConnection(helper,
+ alarm_factory,
+ perspective,
+ supported_versions) {}
+
+PacketSavingConnection::~PacketSavingConnection() {}
+
+void PacketSavingConnection::SendOrQueuePacket(SerializedPacket packet) {
+ encrypted_packets_.push_back(std::make_unique<QuicEncryptedPacket>(
+ CopyBuffer(packet), packet.encrypted_length, true));
+ clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
+ // Transfer ownership of the packet to the SentPacketManager and the
+ // ack notifier to the AckNotifierManager.
+ OnPacketSent(packet.encryption_level, packet.transmission_type);
+ QuicConnectionPeer::GetSentPacketManager(this)->OnPacketSent(
+ &packet, clock_.ApproximateNow(), NOT_RETRANSMISSION,
+ HAS_RETRANSMITTABLE_DATA, true);
+}
+
+MockQuicSession::MockQuicSession(QuicConnection* connection)
+ : MockQuicSession(connection, true) {}
+
+MockQuicSession::MockQuicSession(QuicConnection* connection,
+ bool create_mock_crypto_stream)
+ : QuicSession(connection,
+ nullptr,
+ DefaultQuicConfig(),
+ connection->supported_versions(),
+ /*num_expected_unidirectional_static_streams = */ 0) {
+ if (create_mock_crypto_stream) {
+ crypto_stream_ = std::make_unique<MockQuicCryptoStream>(this);
+ }
+ ON_CALL(*this, WritevData(_, _, _, _, _, _))
+ .WillByDefault(testing::Return(QuicConsumedData(0, false)));
+}
+
+MockQuicSession::~MockQuicSession() {
+ DeleteConnection();
+}
+
+QuicCryptoStream* MockQuicSession::GetMutableCryptoStream() {
+ return crypto_stream_.get();
+}
+
+const QuicCryptoStream* MockQuicSession::GetCryptoStream() const {
+ return crypto_stream_.get();
+}
+
+void MockQuicSession::SetCryptoStream(QuicCryptoStream* crypto_stream) {
+ crypto_stream_.reset(crypto_stream);
+}
+
+QuicConsumedData MockQuicSession::ConsumeData(
+ QuicStreamId id,
+ size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state,
+ TransmissionType /*type*/,
+ absl::optional<EncryptionLevel> /*level*/) {
+ if (write_length > 0) {
+ auto buf = std::make_unique<char[]>(write_length);
+ QuicStream* stream = GetOrCreateStream(id);
+ QUICHE_DCHECK(stream);
+ QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
+ stream->WriteStreamData(offset, write_length, &writer);
+ } else {
+ QUICHE_DCHECK(state != NO_FIN);
+ }
+ return QuicConsumedData(write_length, state != NO_FIN);
+}
+
+MockQuicCryptoStream::MockQuicCryptoStream(QuicSession* session)
+ : QuicCryptoStream(session), params_(new QuicCryptoNegotiatedParameters) {}
+
+MockQuicCryptoStream::~MockQuicCryptoStream() {}
+
+ssl_early_data_reason_t MockQuicCryptoStream::EarlyDataReason() const {
+ return ssl_early_data_unknown;
+}
+
+bool MockQuicCryptoStream::encryption_established() const {
+ return false;
+}
+
+bool MockQuicCryptoStream::one_rtt_keys_available() const {
+ return false;
+}
+
+const QuicCryptoNegotiatedParameters&
+MockQuicCryptoStream::crypto_negotiated_params() const {
+ return *params_;
+}
+
+CryptoMessageParser* MockQuicCryptoStream::crypto_message_parser() {
+ return &crypto_framer_;
+}
+
+MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection)
+ : MockQuicSpdySession(connection, true) {}
+
+MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection,
+ bool create_mock_crypto_stream)
+ : QuicSpdySession(connection,
+ nullptr,
+ DefaultQuicConfig(),
+ connection->supported_versions()) {
+ if (create_mock_crypto_stream) {
+ crypto_stream_ = std::make_unique<MockQuicCryptoStream>(this);
+ }
+
+ ON_CALL(*this, WritevData(_, _, _, _, _, _))
+ .WillByDefault(testing::Return(QuicConsumedData(0, false)));
+
+ ON_CALL(*this, SendWindowUpdate(_, _))
+ .WillByDefault([this](QuicStreamId id, QuicStreamOffset byte_offset) {
+ return QuicSpdySession::SendWindowUpdate(id, byte_offset);
+ });
+
+ ON_CALL(*this, SendBlocked(_)).WillByDefault([this](QuicStreamId id) {
+ return QuicSpdySession::SendBlocked(id);
+ });
+
+ ON_CALL(*this, OnCongestionWindowChange(_)).WillByDefault(testing::Return());
+}
+
+MockQuicSpdySession::~MockQuicSpdySession() {
+ DeleteConnection();
+}
+
+QuicCryptoStream* MockQuicSpdySession::GetMutableCryptoStream() {
+ return crypto_stream_.get();
+}
+
+const QuicCryptoStream* MockQuicSpdySession::GetCryptoStream() const {
+ return crypto_stream_.get();
+}
+
+void MockQuicSpdySession::SetCryptoStream(QuicCryptoStream* crypto_stream) {
+ crypto_stream_.reset(crypto_stream);
+}
+
+QuicConsumedData MockQuicSpdySession::ConsumeData(
+ QuicStreamId id,
+ size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state,
+ TransmissionType /*type*/,
+ absl::optional<EncryptionLevel> /*level*/) {
+ if (write_length > 0) {
+ auto buf = std::make_unique<char[]>(write_length);
+ QuicStream* stream = GetOrCreateStream(id);
+ QUICHE_DCHECK(stream);
+ QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
+ stream->WriteStreamData(offset, write_length, &writer);
+ } else {
+ QUICHE_DCHECK(state != NO_FIN);
+ }
+ return QuicConsumedData(write_length, state != NO_FIN);
+}
+
+TestQuicSpdyServerSession::TestQuicSpdyServerSession(
+ QuicConnection* connection,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache)
+ : QuicServerSessionBase(config,
+ supported_versions,
+ connection,
+ &visitor_,
+ &helper_,
+ crypto_config,
+ compressed_certs_cache) {
+ ON_CALL(helper_, CanAcceptClientHello(_, _, _, _, _))
+ .WillByDefault(testing::Return(true));
+}
+
+TestQuicSpdyServerSession::~TestQuicSpdyServerSession() {
+ DeleteConnection();
+}
+
+std::unique_ptr<QuicCryptoServerStreamBase>
+TestQuicSpdyServerSession::CreateQuicCryptoServerStream(
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache) {
+ return CreateCryptoServerStream(crypto_config, compressed_certs_cache, this,
+ &helper_);
+}
+
+QuicCryptoServerStreamBase*
+TestQuicSpdyServerSession::GetMutableCryptoStream() {
+ return QuicServerSessionBase::GetMutableCryptoStream();
+}
+
+const QuicCryptoServerStreamBase* TestQuicSpdyServerSession::GetCryptoStream()
+ const {
+ return QuicServerSessionBase::GetCryptoStream();
+}
+
+TestQuicSpdyClientSession::TestQuicSpdyClientSession(
+ QuicConnection* connection,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ const QuicServerId& server_id,
+ QuicCryptoClientConfig* crypto_config)
+ : QuicSpdyClientSessionBase(connection,
+ &push_promise_index_,
+ config,
+ supported_versions) {
+ // TODO(b/153726130): Consider adding SetServerApplicationStateForResumption
+ // calls in tests and set |has_application_state| to true.
+ crypto_stream_ = std::make_unique<QuicCryptoClientStream>(
+ server_id, this, crypto_test_utils::ProofVerifyContextForTesting(),
+ crypto_config, this, /*has_application_state = */ false);
+ Initialize();
+ ON_CALL(*this, OnConfigNegotiated())
+ .WillByDefault(
+ Invoke(this, &TestQuicSpdyClientSession::RealOnConfigNegotiated));
+}
+
+TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {}
+
+bool TestQuicSpdyClientSession::IsAuthorized(const std::string& /*authority*/) {
+ return true;
+}
+
+QuicCryptoClientStream* TestQuicSpdyClientSession::GetMutableCryptoStream() {
+ return crypto_stream_.get();
+}
+
+const QuicCryptoClientStream* TestQuicSpdyClientSession::GetCryptoStream()
+ const {
+ return crypto_stream_.get();
+}
+
+void TestQuicSpdyClientSession::RealOnConfigNegotiated() {
+ QuicSpdyClientSessionBase::OnConfigNegotiated();
+}
+
+TestPushPromiseDelegate::TestPushPromiseDelegate(bool match)
+ : match_(match), rendezvous_fired_(false), rendezvous_stream_(nullptr) {}
+
+bool TestPushPromiseDelegate::CheckVary(
+ const spdy::SpdyHeaderBlock& /*client_request*/,
+ const spdy::SpdyHeaderBlock& /*promise_request*/,
+ const spdy::SpdyHeaderBlock& /*promise_response*/) {
+ QUIC_DVLOG(1) << "match " << match_;
+ return match_;
+}
+
+void TestPushPromiseDelegate::OnRendezvousResult(QuicSpdyStream* stream) {
+ rendezvous_fired_ = true;
+ rendezvous_stream_ = stream;
+}
+
+MockPacketWriter::MockPacketWriter() {
+ ON_CALL(*this, GetMaxPacketSize(_))
+ .WillByDefault(testing::Return(kMaxOutgoingPacketSize));
+ ON_CALL(*this, IsBatchMode()).WillByDefault(testing::Return(false));
+ ON_CALL(*this, GetNextWriteLocation(_, _))
+ .WillByDefault(testing::Return(QuicPacketBuffer()));
+ ON_CALL(*this, Flush())
+ .WillByDefault(testing::Return(WriteResult(WRITE_STATUS_OK, 0)));
+ ON_CALL(*this, SupportsReleaseTime()).WillByDefault(testing::Return(false));
+}
+
+MockPacketWriter::~MockPacketWriter() {}
+
+MockSendAlgorithm::MockSendAlgorithm() {
+ ON_CALL(*this, PacingRate(_))
+ .WillByDefault(testing::Return(QuicBandwidth::Zero()));
+ ON_CALL(*this, BandwidthEstimate())
+ .WillByDefault(testing::Return(QuicBandwidth::Zero()));
+}
+
+MockSendAlgorithm::~MockSendAlgorithm() {}
+
+MockLossAlgorithm::MockLossAlgorithm() {}
+
+MockLossAlgorithm::~MockLossAlgorithm() {}
+
+MockAckListener::MockAckListener() {}
+
+MockAckListener::~MockAckListener() {}
+
+MockNetworkChangeVisitor::MockNetworkChangeVisitor() {}
+
+MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {}
+
+QuicIpAddress TestPeerIPAddress() {
+ return QuicIpAddress::Loopback4();
+}
+
+ParsedQuicVersion QuicVersionMax() {
+ return AllSupportedVersions().front();
+}
+
+ParsedQuicVersion QuicVersionMin() {
+ return AllSupportedVersions().back();
+}
+
+void DisableQuicVersionsWithTls() {
+ for (const ParsedQuicVersion& version : AllSupportedVersionsWithTls()) {
+ QuicDisableVersion(version);
+ }
+}
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data) {
+ return ConstructEncryptedPacket(
+ destination_connection_id, source_connection_id, version_flag, reset_flag,
+ packet_number, data, CONNECTION_ID_PRESENT, CONNECTION_ID_ABSENT,
+ PACKET_4BYTE_PACKET_NUMBER);
+}
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length) {
+ return ConstructEncryptedPacket(
+ destination_connection_id, source_connection_id, version_flag, reset_flag,
+ packet_number, data, destination_connection_id_included,
+ source_connection_id_included, packet_number_length, nullptr);
+}
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions) {
+ return ConstructEncryptedPacket(
+ destination_connection_id, source_connection_id, version_flag, reset_flag,
+ packet_number, data, false, destination_connection_id_included,
+ source_connection_id_included, packet_number_length, versions,
+ Perspective::IS_CLIENT);
+}
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data,
+ bool full_padding,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions) {
+ return ConstructEncryptedPacket(
+ destination_connection_id, source_connection_id, version_flag, reset_flag,
+ packet_number, data, full_padding, destination_connection_id_included,
+ source_connection_id_included, packet_number_length, versions,
+ Perspective::IS_CLIENT);
+}
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data,
+ bool full_padding,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions,
+ Perspective perspective) {
+ QuicPacketHeader header;
+ header.destination_connection_id = destination_connection_id;
+ header.destination_connection_id_included =
+ destination_connection_id_included;
+ header.source_connection_id = source_connection_id;
+ header.source_connection_id_included = source_connection_id_included;
+ header.version_flag = version_flag;
+ header.reset_flag = reset_flag;
+ header.packet_number_length = packet_number_length;
+ header.packet_number = QuicPacketNumber(packet_number);
+ ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
+ if (!versions) {
+ versions = &supported_versions;
+ }
+ EXPECT_FALSE(versions->empty());
+ ParsedQuicVersion version = (*versions)[0];
+ if (QuicVersionHasLongHeaderLengths(version.transport_version) &&
+ version_flag) {
+ header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ }
+
+ QuicFrames frames;
+ QuicFramer framer(*versions, QuicTime::Zero(), perspective,
+ kQuicDefaultConnectionIdLength);
+ framer.SetInitialObfuscators(destination_connection_id);
+ EncryptionLevel level =
+ header.version_flag ? ENCRYPTION_INITIAL : ENCRYPTION_FORWARD_SECURE;
+ if (level != ENCRYPTION_INITIAL) {
+ framer.SetEncrypter(level, std::make_unique<NullEncrypter>(perspective));
+ }
+ if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
+ QuicFrame frame(
+ QuicStreamFrame(QuicUtils::GetCryptoStreamId(version.transport_version),
+ false, 0, absl::string_view(data)));
+ frames.push_back(frame);
+ } else {
+ QuicFrame frame(new QuicCryptoFrame(level, 0, data));
+ frames.push_back(frame);
+ }
+ if (full_padding) {
+ frames.push_back(QuicFrame(QuicPaddingFrame(-1)));
+ } else {
+ // We need a minimum number of bytes of encrypted payload. This will
+ // guarantee that we have at least that much. (It ignores the overhead of
+ // the stream/crypto framing, so it overpads slightly.)
+ size_t min_plaintext_size =
+ QuicPacketCreator::MinPlaintextPacketSize(version);
+ if (data.length() < min_plaintext_size) {
+ size_t padding_length = min_plaintext_size - data.length();
+ frames.push_back(QuicFrame(QuicPaddingFrame(padding_length)));
+ }
+ }
+
+ std::unique_ptr<QuicPacket> packet(
+ BuildUnsizedDataPacket(&framer, header, frames));
+ EXPECT_TRUE(packet != nullptr);
+ char* buffer = new char[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ framer.EncryptPayload(level, QuicPacketNumber(packet_number), *packet,
+ buffer, kMaxOutgoingPacketSize);
+ EXPECT_NE(0u, encrypted_length);
+ DeleteFrames(&frames);
+ return new QuicEncryptedPacket(buffer, encrypted_length, true);
+}
+
+std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id) {
+ QuicPacketHeader header;
+ header.destination_connection_id = server_connection_id;
+ header.destination_connection_id_included = CONNECTION_ID_PRESENT;
+ header.source_connection_id = EmptyQuicConnectionId();
+ header.source_connection_id_included = CONNECTION_ID_PRESENT;
+ if (!version.SupportsClientConnectionIds()) {
+ header.source_connection_id_included = CONNECTION_ID_ABSENT;
+ }
+ header.version_flag = true;
+ header.reset_flag = false;
+ header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
+ header.packet_number = QuicPacketNumber(33);
+ header.long_packet_type = ZERO_RTT_PROTECTED;
+ if (version.HasLongHeaderLengths()) {
+ header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ }
+
+ QuicFrames frames;
+ frames.push_back(QuicFrame(QuicPingFrame()));
+ frames.push_back(QuicFrame(QuicPaddingFrame(100)));
+ QuicFramer framer({version}, QuicTime::Zero(), Perspective::IS_CLIENT,
+ kQuicDefaultConnectionIdLength);
+ framer.SetInitialObfuscators(server_connection_id);
+
+ framer.SetEncrypter(ENCRYPTION_ZERO_RTT,
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
+ std::unique_ptr<QuicPacket> packet(
+ BuildUnsizedDataPacket(&framer, header, frames));
+ EXPECT_TRUE(packet != nullptr);
+ char* buffer = new char[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ framer.EncryptPayload(ENCRYPTION_ZERO_RTT, header.packet_number, *packet,
+ buffer, kMaxOutgoingPacketSize);
+ EXPECT_NE(0u, encrypted_length);
+ DeleteFrames(&frames);
+ return std::make_unique<QuicEncryptedPacket>(buffer, encrypted_length,
+ /*owns_buffer=*/true);
+}
+
+QuicReceivedPacket* ConstructReceivedPacket(
+ const QuicEncryptedPacket& encrypted_packet,
+ QuicTime receipt_time) {
+ char* buffer = new char[encrypted_packet.length()];
+ memcpy(buffer, encrypted_packet.data(), encrypted_packet.length());
+ return new QuicReceivedPacket(buffer, encrypted_packet.length(), receipt_time,
+ true);
+}
+
+QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ bool version_flag,
+ bool reset_flag,
+ uint64_t packet_number,
+ const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersion version,
+ Perspective perspective) {
+ QuicPacketHeader header;
+ header.destination_connection_id = destination_connection_id;
+ header.destination_connection_id_included =
+ destination_connection_id_included;
+ header.source_connection_id = source_connection_id;
+ header.source_connection_id_included = source_connection_id_included;
+ header.version_flag = version_flag;
+ header.reset_flag = reset_flag;
+ header.packet_number_length = packet_number_length;
+ header.packet_number = QuicPacketNumber(packet_number);
+ if (QuicVersionHasLongHeaderLengths(version.transport_version) &&
+ version_flag) {
+ header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ }
+ QuicFrame frame(QuicStreamFrame(1, false, 0, absl::string_view(data)));
+ QuicFrames frames;
+ frames.push_back(frame);
+ QuicFramer framer({version}, QuicTime::Zero(), perspective,
+ kQuicDefaultConnectionIdLength);
+ framer.SetInitialObfuscators(destination_connection_id);
+ EncryptionLevel level =
+ version_flag ? ENCRYPTION_INITIAL : ENCRYPTION_FORWARD_SECURE;
+ if (level != ENCRYPTION_INITIAL) {
+ framer.SetEncrypter(level, std::make_unique<NullEncrypter>(perspective));
+ }
+ // We need a minimum of 7 bytes of encrypted payload. This will guarantee that
+ // we have at least that much. (It ignores the overhead of the stream/crypto
+ // framing, so it overpads slightly.)
+ if (data.length() < 7) {
+ size_t padding_length = 7 - data.length();
+ frames.push_back(QuicFrame(QuicPaddingFrame(padding_length)));
+ }
+
+ std::unique_ptr<QuicPacket> packet(
+ BuildUnsizedDataPacket(&framer, header, frames));
+ EXPECT_TRUE(packet != nullptr);
+
+ // Now set the frame type to 0x1F, which is an invalid frame type.
+ reinterpret_cast<unsigned char*>(
+ packet->mutable_data())[GetStartOfEncryptedData(
+ framer.transport_version(),
+ GetIncludedDestinationConnectionIdLength(header),
+ GetIncludedSourceConnectionIdLength(header), version_flag,
+ false /* no diversification nonce */, packet_number_length,
+ header.retry_token_length_length, 0, header.length_length)] = 0x1F;
+
+ char* buffer = new char[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ framer.EncryptPayload(level, QuicPacketNumber(packet_number), *packet,
+ buffer, kMaxOutgoingPacketSize);
+ EXPECT_NE(0u, encrypted_length);
+ return new QuicEncryptedPacket(buffer, encrypted_length, true);
+}
+
+QuicConfig DefaultQuicConfig() {
+ QuicConfig config;
+ config.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
+ kInitialStreamFlowControlWindowForTest);
+ config.SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(
+ kInitialStreamFlowControlWindowForTest);
+ config.SetInitialMaxStreamDataBytesUnidirectionalToSend(
+ kInitialStreamFlowControlWindowForTest);
+ config.SetInitialStreamFlowControlWindowToSend(
+ kInitialStreamFlowControlWindowForTest);
+ config.SetInitialSessionFlowControlWindowToSend(
+ kInitialSessionFlowControlWindowForTest);
+ QuicConfigPeer::SetReceivedMaxBidirectionalStreams(
+ &config, kDefaultMaxStreamsPerConnection);
+ // Default enable NSTP.
+ // This is unnecessary for versions > 44
+ if (!config.HasClientSentConnectionOption(quic::kNSTP,
+ quic::Perspective::IS_CLIENT)) {
+ quic::QuicTagVector connection_options;
+ connection_options.push_back(quic::kNSTP);
+ config.SetConnectionOptionsToSend(connection_options);
+ }
+ return config;
+}
+
+ParsedQuicVersionVector SupportedVersions(ParsedQuicVersion version) {
+ ParsedQuicVersionVector versions;
+ versions.push_back(version);
+ return versions;
+}
+
+MockQuicConnectionDebugVisitor::MockQuicConnectionDebugVisitor() {}
+
+MockQuicConnectionDebugVisitor::~MockQuicConnectionDebugVisitor() {}
+
+MockReceivedPacketManager::MockReceivedPacketManager(QuicConnectionStats* stats)
+ : QuicReceivedPacketManager(stats) {}
+
+MockReceivedPacketManager::~MockReceivedPacketManager() {}
+
+MockPacketCreatorDelegate::MockPacketCreatorDelegate() {}
+MockPacketCreatorDelegate::~MockPacketCreatorDelegate() {}
+
+MockSessionNotifier::MockSessionNotifier() {}
+MockSessionNotifier::~MockSessionNotifier() {}
+
+// static
+QuicCryptoClientStream::HandshakerInterface*
+QuicCryptoClientStreamPeer::GetHandshaker(QuicCryptoClientStream* stream) {
+ return stream->handshaker_.get();
+}
+
+void CreateClientSessionForTest(
+ QuicServerId server_id,
+ QuicTime::Delta connection_start_time,
+ const ParsedQuicVersionVector& supported_versions,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ QuicCryptoClientConfig* crypto_client_config,
+ PacketSavingConnection** client_connection,
+ TestQuicSpdyClientSession** client_session) {
+ QUICHE_CHECK(crypto_client_config);
+ QUICHE_CHECK(client_connection);
+ QUICHE_CHECK(client_session);
+ QUICHE_CHECK(!connection_start_time.IsZero())
+ << "Connections must start at non-zero times, otherwise the "
+ << "strike-register will be unhappy.";
+
+ QuicConfig config = DefaultQuicConfig();
+ *client_connection = new PacketSavingConnection(
+ helper, alarm_factory, Perspective::IS_CLIENT, supported_versions);
+ *client_session = new TestQuicSpdyClientSession(*client_connection, config,
+ supported_versions, server_id,
+ crypto_client_config);
+ (*client_connection)->AdvanceTime(connection_start_time);
+}
+
+void CreateServerSessionForTest(
+ QuicServerId /*server_id*/,
+ QuicTime::Delta connection_start_time,
+ ParsedQuicVersionVector supported_versions,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ QuicCryptoServerConfig* server_crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ PacketSavingConnection** server_connection,
+ TestQuicSpdyServerSession** server_session) {
+ QUICHE_CHECK(server_crypto_config);
+ QUICHE_CHECK(server_connection);
+ QUICHE_CHECK(server_session);
+ QUICHE_CHECK(!connection_start_time.IsZero())
+ << "Connections must start at non-zero times, otherwise the "
+ << "strike-register will be unhappy.";
+
+ *server_connection =
+ new PacketSavingConnection(helper, alarm_factory, Perspective::IS_SERVER,
+ ParsedVersionOfIndex(supported_versions, 0));
+ *server_session = new TestQuicSpdyServerSession(
+ *server_connection, DefaultQuicConfig(), supported_versions,
+ server_crypto_config, compressed_certs_cache);
+ (*server_session)->Initialize();
+
+ // We advance the clock initially because the default time is zero and the
+ // strike register worries that we've just overflowed a uint32_t time.
+ (*server_connection)->AdvanceTime(connection_start_time);
+}
+
+QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
+ QuicTransportVersion version,
+ int n) {
+ int num = n;
+ if (!VersionUsesHttp3(version)) {
+ num++;
+ }
+ return QuicUtils::GetFirstBidirectionalStreamId(version,
+ Perspective::IS_CLIENT) +
+ QuicUtils::StreamIdDelta(version) * num;
+}
+
+QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
+ QuicTransportVersion version,
+ int n) {
+ return QuicUtils::GetFirstBidirectionalStreamId(version,
+ Perspective::IS_SERVER) +
+ QuicUtils::StreamIdDelta(version) * n;
+}
+
+QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
+ QuicTransportVersion version,
+ int n) {
+ return QuicUtils::GetFirstUnidirectionalStreamId(version,
+ Perspective::IS_SERVER) +
+ QuicUtils::StreamIdDelta(version) * n;
+}
+
+QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
+ QuicTransportVersion version,
+ int n) {
+ return QuicUtils::GetFirstUnidirectionalStreamId(version,
+ Perspective::IS_CLIENT) +
+ QuicUtils::StreamIdDelta(version) * n;
+}
+
+StreamType DetermineStreamType(QuicStreamId id,
+ ParsedQuicVersion version,
+ Perspective perspective,
+ bool is_incoming,
+ StreamType default_type) {
+ return version.HasIetfQuicFrames()
+ ? QuicUtils::GetStreamType(id, perspective, is_incoming, version)
+ : default_type;
+}
+
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data) {
+ if (data.empty()) {
+ return quiche::QuicheMemSlice();
+ }
+
+ static quiche::SimpleBufferAllocator* allocator =
+ new quiche::SimpleBufferAllocator();
+ return quiche::QuicheMemSlice(quiche::QuicheBuffer::Copy(allocator, data));
+}
+
+bool TaggingEncrypter::EncryptPacket(uint64_t /*packet_number*/,
+ absl::string_view /*associated_data*/,
+ absl::string_view plaintext,
+ char* output,
+ size_t* output_length,
+ size_t max_output_length) {
+ const size_t len = plaintext.size() + kTagSize;
+ if (max_output_length < len) {
+ return false;
+ }
+ // Memmove is safe for inplace encryption.
+ memmove(output, plaintext.data(), plaintext.size());
+ output += plaintext.size();
+ memset(output, tag_, kTagSize);
+ *output_length = len;
+ return true;
+}
+
+bool TaggingDecrypter::DecryptPacket(uint64_t /*packet_number*/,
+ absl::string_view /*associated_data*/,
+ absl::string_view ciphertext,
+ char* output,
+ size_t* output_length,
+ size_t /*max_output_length*/) {
+ if (ciphertext.size() < kTagSize) {
+ return false;
+ }
+ if (!CheckTag(ciphertext, GetTag(ciphertext))) {
+ return false;
+ }
+ *output_length = ciphertext.size() - kTagSize;
+ memcpy(output, ciphertext.data(), *output_length);
+ return true;
+}
+
+bool TaggingDecrypter::CheckTag(absl::string_view ciphertext, uint8_t tag) {
+ for (size_t i = ciphertext.size() - kTagSize; i < ciphertext.size(); i++) {
+ if (ciphertext.data()[i] != tag) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+TestPacketWriter::TestPacketWriter(ParsedQuicVersion version,
+ MockClock* clock,
+ Perspective perspective)
+ : version_(version),
+ framer_(SupportedVersions(version_),
+ QuicUtils::InvertPerspective(perspective)),
+ clock_(clock) {
+ QuicFramerPeer::SetLastSerializedServerConnectionId(framer_.framer(),
+ TestConnectionId());
+ framer_.framer()->SetInitialObfuscators(TestConnectionId());
+
+ for (int i = 0; i < 128; ++i) {
+ PacketBuffer* p = new PacketBuffer();
+ packet_buffer_pool_.push_back(p);
+ packet_buffer_pool_index_[p->buffer] = p;
+ packet_buffer_free_list_.push_back(p);
+ }
+}
+
+TestPacketWriter::~TestPacketWriter() {
+ EXPECT_EQ(packet_buffer_pool_.size(), packet_buffer_free_list_.size())
+ << packet_buffer_pool_.size() - packet_buffer_free_list_.size()
+ << " out of " << packet_buffer_pool_.size()
+ << " packet buffers have been leaked.";
+ for (auto p : packet_buffer_pool_) {
+ delete p;
+ }
+}
+
+WriteResult TestPacketWriter::WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* /*options*/) {
+ last_write_source_address_ = self_address;
+ last_write_peer_address_ = peer_address;
+ // If the buffer is allocated from the pool, return it back to the pool.
+ // Note the buffer content doesn't change.
+ if (packet_buffer_pool_index_.find(const_cast<char*>(buffer)) !=
+ packet_buffer_pool_index_.end()) {
+ FreePacketBuffer(buffer);
+ }
+
+ QuicEncryptedPacket packet(buffer, buf_len);
+ ++packets_write_attempts_;
+
+ if (packet.length() >= sizeof(final_bytes_of_last_packet_)) {
+ final_bytes_of_previous_packet_ = final_bytes_of_last_packet_;
+ memcpy(&final_bytes_of_last_packet_, packet.data() + packet.length() - 4,
+ sizeof(final_bytes_of_last_packet_));
+ }
+
+ if (use_tagging_decrypter_) {
+ if (framer_.framer()->version().KnowsWhichDecrypterToUse()) {
+ framer_.framer()->InstallDecrypter(ENCRYPTION_INITIAL,
+ std::make_unique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(ENCRYPTION_HANDSHAKE,
+ std::make_unique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(ENCRYPTION_ZERO_RTT,
+ std::make_unique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<TaggingDecrypter>());
+ } else {
+ framer_.framer()->SetDecrypter(ENCRYPTION_INITIAL,
+ std::make_unique<TaggingDecrypter>());
+ }
+ } else if (framer_.framer()->version().KnowsWhichDecrypterToUse()) {
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_HANDSHAKE,
+ std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_ZERO_RTT,
+ std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
+ }
+ EXPECT_TRUE(framer_.ProcessPacket(packet))
+ << framer_.framer()->detailed_error() << " perspective "
+ << framer_.framer()->perspective();
+ if (block_on_next_write_) {
+ write_blocked_ = true;
+ block_on_next_write_ = false;
+ }
+ if (next_packet_too_large_) {
+ next_packet_too_large_ = false;
+ return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
+ }
+ if (always_get_packet_too_large_) {
+ return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
+ }
+ if (IsWriteBlocked()) {
+ return WriteResult(is_write_blocked_data_buffered_
+ ? WRITE_STATUS_BLOCKED_DATA_BUFFERED
+ : WRITE_STATUS_BLOCKED,
+ 0);
+ }
+
+ if (ShouldWriteFail()) {
+ return WriteResult(WRITE_STATUS_ERROR, write_error_code_);
+ }
+
+ last_packet_size_ = packet.length();
+ last_packet_header_ = framer_.header();
+ if (!framer_.connection_close_frames().empty()) {
+ ++connection_close_packets_;
+ }
+ if (!write_pause_time_delta_.IsZero()) {
+ clock_->AdvanceTime(write_pause_time_delta_);
+ }
+ if (is_batch_mode_) {
+ bytes_buffered_ += last_packet_size_;
+ return WriteResult(WRITE_STATUS_OK, 0);
+ }
+ return WriteResult(WRITE_STATUS_OK, last_packet_size_);
+}
+
+QuicPacketBuffer TestPacketWriter::GetNextWriteLocation(
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/) {
+ return {AllocPacketBuffer(), [this](const char* p) { FreePacketBuffer(p); }};
+}
+
+WriteResult TestPacketWriter::Flush() {
+ flush_attempts_++;
+ if (block_on_next_flush_) {
+ block_on_next_flush_ = false;
+ SetWriteBlocked();
+ return WriteResult(WRITE_STATUS_BLOCKED, /*errno*/ -1);
+ }
+ if (write_should_fail_) {
+ return WriteResult(WRITE_STATUS_ERROR, /*errno*/ -1);
+ }
+ int bytes_flushed = bytes_buffered_;
+ bytes_buffered_ = 0;
+ return WriteResult(WRITE_STATUS_OK, bytes_flushed);
+}
+
+char* TestPacketWriter::AllocPacketBuffer() {
+ PacketBuffer* p = packet_buffer_free_list_.front();
+ EXPECT_FALSE(p->in_use);
+ p->in_use = true;
+ packet_buffer_free_list_.pop_front();
+ return p->buffer;
+}
+
+void TestPacketWriter::FreePacketBuffer(const char* buffer) {
+ auto iter = packet_buffer_pool_index_.find(const_cast<char*>(buffer));
+ ASSERT_TRUE(iter != packet_buffer_pool_index_.end());
+ PacketBuffer* p = iter->second;
+ ASSERT_TRUE(p->in_use);
+ p->in_use = false;
+ packet_buffer_free_list_.push_back(p);
+}
+
+bool WriteServerVersionNegotiationProbeResponse(
+ char* packet_bytes,
+ size_t* packet_length_out,
+ const char* source_connection_id_bytes,
+ uint8_t source_connection_id_length) {
+ if (packet_bytes == nullptr) {
+ QUIC_BUG(quic_bug_10256_1) << "Invalid packet_bytes";
+ return false;
+ }
+ if (packet_length_out == nullptr) {
+ QUIC_BUG(quic_bug_10256_2) << "Invalid packet_length_out";
+ return false;
+ }
+ QuicConnectionId source_connection_id(source_connection_id_bytes,
+ source_connection_id_length);
+ std::unique_ptr<QuicEncryptedPacket> encrypted_packet =
+ QuicFramer::BuildVersionNegotiationPacket(
+ source_connection_id, EmptyQuicConnectionId(),
+ /*ietf_quic=*/true, /*use_length_prefix=*/true,
+ ParsedQuicVersionVector{});
+ if (!encrypted_packet) {
+ QUIC_BUG(quic_bug_10256_3) << "Failed to create version negotiation packet";
+ return false;
+ }
+ if (*packet_length_out < encrypted_packet->length()) {
+ QUIC_BUG(quic_bug_10256_4)
+ << "Invalid *packet_length_out " << *packet_length_out << " < "
+ << encrypted_packet->length();
+ return false;
+ }
+ *packet_length_out = encrypted_packet->length();
+ memcpy(packet_bytes, encrypted_packet->data(), *packet_length_out);
+ return true;
+}
+
+bool ParseClientVersionNegotiationProbePacket(
+ const char* packet_bytes,
+ size_t packet_length,
+ char* destination_connection_id_bytes,
+ uint8_t* destination_connection_id_length_out) {
+ if (packet_bytes == nullptr) {
+ QUIC_BUG(quic_bug_10256_5) << "Invalid packet_bytes";
+ return false;
+ }
+ if (packet_length < kMinPacketSizeForVersionNegotiation ||
+ packet_length > 65535) {
+ QUIC_BUG(quic_bug_10256_6) << "Invalid packet_length";
+ return false;
+ }
+ if (destination_connection_id_bytes == nullptr) {
+ QUIC_BUG(quic_bug_10256_7) << "Invalid destination_connection_id_bytes";
+ return false;
+ }
+ if (destination_connection_id_length_out == nullptr) {
+ QUIC_BUG(quic_bug_10256_8)
+ << "Invalid destination_connection_id_length_out";
+ return false;
+ }
+
+ QuicEncryptedPacket encrypted_packet(packet_bytes, packet_length);
+ PacketHeaderFormat format;
+ QuicLongHeaderType long_packet_type;
+ bool version_present, has_length_prefix;
+ QuicVersionLabel version_label;
+ ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
+ QuicConnectionId destination_connection_id, source_connection_id;
+ absl::optional<absl::string_view> retry_token;
+ std::string detailed_error;
+ QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
+ encrypted_packet,
+ /*expected_destination_connection_id_length=*/0, &format,
+ &long_packet_type, &version_present, &has_length_prefix, &version_label,
+ &parsed_version, &destination_connection_id, &source_connection_id,
+ &retry_token, &detailed_error);
+ if (error != QUIC_NO_ERROR) {
+ QUIC_BUG(quic_bug_10256_9) << "Failed to parse packet: " << detailed_error;
+ return false;
+ }
+ if (!version_present) {
+ QUIC_BUG(quic_bug_10256_10) << "Packet is not a long header";
+ return false;
+ }
+ if (*destination_connection_id_length_out <
+ destination_connection_id.length()) {
+ QUIC_BUG(quic_bug_10256_11)
+ << "destination_connection_id_length_out too small";
+ return false;
+ }
+ *destination_connection_id_length_out = destination_connection_id.length();
+ memcpy(destination_connection_id_bytes, destination_connection_id.data(),
+ *destination_connection_id_length_out);
+ return true;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
new file mode 100644
index 0000000..80a88d1
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -0,0 +1,2036 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Common utilities for Quic tests
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/congestion_control/loss_detection_interface.h"
+#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
+#include "quiche/quic/core/crypto/transport_parameters.h"
+#include "quiche/quic/core/http/quic_client_push_promise_index.h"
+#include "quiche/quic/core/http/quic_server_session_base.h"
+#include "quiche/quic/core/http/quic_spdy_session.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_error_codes.h"
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_path_validator.h"
+#include "quiche/quic/core/quic_sent_packet_manager.h"
+#include "quiche/quic/core/quic_server_id.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_clock.h"
+#include "quiche/quic/test_tools/mock_quic_session_visitor.h"
+#include "quiche/quic/test_tools/mock_random.h"
+#include "quiche/quic/test_tools/quic_framer_peer.h"
+#include "quiche/quic/test_tools/simple_quic_framer.h"
+#include "quiche/common/quiche_mem_slice_storage.h"
+#include "quiche/common/simple_buffer_allocator.h"
+
+namespace quic {
+
+namespace test {
+
+// A generic predictable connection ID suited for testing.
+QuicConnectionId TestConnectionId();
+
+// A generic predictable connection ID suited for testing, generated from a
+// given number, such as an index.
+QuicConnectionId TestConnectionId(uint64_t connection_number);
+
+// A generic predictable connection ID suited for testing, generated from a
+// given number, such as an index. Guaranteed to be 9 bytes long.
+QuicConnectionId TestConnectionIdNineBytesLong(uint64_t connection_number);
+
+// Extracts the connection number passed to TestConnectionId().
+uint64_t TestConnectionIdToUInt64(QuicConnectionId connection_id);
+
+enum : uint16_t { kTestPort = 12345 };
+enum : uint32_t {
+ kMaxDatagramFrameSizeForTest = 1333,
+ kMaxPacketSizeForTest = 9001,
+ kInitialStreamFlowControlWindowForTest = 1024 * 1024, // 1 MB
+ kInitialSessionFlowControlWindowForTest = 1536 * 1024, // 1.5 MB
+};
+
+enum : uint64_t {
+ kAckDelayExponentForTest = 10,
+ kMaxAckDelayForTest = 51, // ms
+ kActiveConnectionIdLimitForTest = 52,
+ kMinAckDelayUsForTest = 1000
+};
+
+// Create an arbitrary stateless reset token, same across multiple calls.
+std::vector<uint8_t> CreateStatelessResetTokenForTest();
+
+// A hostname useful for testing, returns "test.example.org".
+std::string TestHostname();
+
+// A server ID useful for testing, returns test.example.org:12345.
+QuicServerId TestServerId();
+
+// Returns the test peer IP address.
+QuicIpAddress TestPeerIPAddress();
+
+// Upper limit on versions we support.
+ParsedQuicVersion QuicVersionMax();
+
+// Lower limit on versions we support.
+ParsedQuicVersion QuicVersionMin();
+
+// Disables all flags that enable QUIC versions that use TLS.
+// This is only meant as a temporary measure to prevent some broken tests
+// from running with TLS.
+void DisableQuicVersionsWithTls();
+
+// Create an encrypted packet for testing.
+// If versions == nullptr, uses &AllSupportedVersions().
+// Note that the packet is encrypted with NullEncrypter, so to decrypt the
+// constructed packet, the framer must be set to use NullDecrypter.
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data, bool full_padding,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions, Perspective perspective);
+
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data, bool full_padding,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions);
+
+// Create an encrypted packet for testing.
+// If versions == nullptr, uses &AllSupportedVersions().
+// Note that the packet is encrypted with NullEncrypter, so to decrypt the
+// constructed packet, the framer must be set to use NullDecrypter.
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length,
+ ParsedQuicVersionVector* versions);
+
+// This form assumes |versions| == nullptr.
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length);
+
+// This form assumes |connection_id_length| == PACKET_8BYTE_CONNECTION_ID,
+// |packet_number_length| == PACKET_4BYTE_PACKET_NUMBER and
+// |versions| == nullptr.
+QuicEncryptedPacket* ConstructEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data);
+
+// Creates a client-to-server ZERO-RTT packet that will fail to decrypt.
+std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
+ const ParsedQuicVersion& version,
+ const QuicConnectionId& server_connection_id);
+
+// Constructs a received packet for testing. The caller must take ownership
+// of the returned pointer.
+QuicReceivedPacket* ConstructReceivedPacket(
+ const QuicEncryptedPacket& encrypted_packet, QuicTime receipt_time);
+
+// Create an encrypted packet for testing whose data portion erroneous.
+// The specific way the data portion is erroneous is not specified, but
+// it is an error that QuicFramer detects.
+// Note that the packet is encrypted with NullEncrypter, so to decrypt the
+// constructed packet, the framer must be set to use NullDecrypter.
+QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
+ QuicConnectionIdIncluded destination_connection_id_included,
+ QuicConnectionIdIncluded source_connection_id_included,
+ QuicPacketNumberLength packet_number_length, ParsedQuicVersion version,
+ Perspective perspective);
+
+// Returns QuicConfig set to default values.
+QuicConfig DefaultQuicConfig();
+
+ParsedQuicVersionVector SupportedVersions(ParsedQuicVersion version);
+
+struct QuicAckBlock {
+ QuicPacketNumber start; // Included
+ QuicPacketNumber limit; // Excluded
+};
+
+// Testing convenience method to construct a QuicAckFrame with arbitrary ack
+// blocks. Each block is given by a (closed-open) range of packet numbers. e.g.:
+// InitAckFrame({{1, 10}})
+// => 1 ack block acking packet numbers 1 to 9.
+//
+// InitAckFrame({{1, 2}, {3, 4}})
+// => 2 ack blocks acking packet 1 and 3. Packet 2 is missing.
+QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks);
+
+// Testing convenience method to construct a QuicAckFrame with 1 ack block which
+// covers packet number range [1, |largest_acked| + 1).
+// Equivalent to InitAckFrame({{1, largest_acked + 1}})
+QuicAckFrame InitAckFrame(uint64_t largest_acked);
+QuicAckFrame InitAckFrame(QuicPacketNumber largest_acked);
+
+// Testing convenience method to construct a QuicAckFrame with |num_ack_blocks|
+// ack blocks of width 1 packet, starting from |least_unacked| + 2.
+QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks,
+ uint64_t least_unacked);
+
+// Testing convenice method to construct a QuicAckFrame with |largest_acked|,
+// ack blocks of width 1 packet and |gap_size|.
+QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size, size_t max_num_gaps,
+ uint64_t largest_acked);
+
+// Returns the encryption level that corresponds to the header type in
+// |header|. If the header is for GOOGLE_QUIC_PACKET instead of an
+// IETF-invariants packet, this function returns ENCRYPTION_INITIAL.
+EncryptionLevel HeaderToEncryptionLevel(const QuicPacketHeader& header);
+
+// Returns a QuicPacket that is owned by the caller, and
+// is populated with the fields in |header| and |frames|, or is nullptr if the
+// packet could not be created.
+std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
+ QuicFramer* framer, const QuicPacketHeader& header,
+ const QuicFrames& frames);
+// Returns a QuicPacket that is owned by the caller, and of size |packet_size|.
+std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
+ QuicFramer* framer, const QuicPacketHeader& header,
+ const QuicFrames& frames, size_t packet_size);
+
+// Compute SHA-1 hash of the supplied std::string.
+std::string Sha1Hash(absl::string_view data);
+
+// Delete |frame| and return true.
+bool ClearControlFrame(const QuicFrame& frame);
+bool ClearControlFrameWithTransmissionType(const QuicFrame& frame,
+ TransmissionType type);
+
+// Simple random number generator used to compute random numbers suitable
+// for pseudo-randomly dropping packets in tests.
+class SimpleRandom : public QuicRandom {
+ public:
+ SimpleRandom() { set_seed(0); }
+ SimpleRandom(const SimpleRandom&) = delete;
+ SimpleRandom& operator=(const SimpleRandom&) = delete;
+ ~SimpleRandom() override {}
+
+ // Generates |len| random bytes in the |data| buffer.
+ void RandBytes(void* data, size_t len) override;
+ // Returns a random number in the range [0, kuint64max].
+ uint64_t RandUint64() override;
+
+ // InsecureRandBytes behaves equivalently to RandBytes.
+ void InsecureRandBytes(void* data, size_t len) override;
+ // InsecureRandUint64 behaves equivalently to RandUint64.
+ uint64_t InsecureRandUint64() override;
+
+ void set_seed(uint64_t seed);
+
+ private:
+ uint8_t buffer_[4096];
+ size_t buffer_offset_ = 0;
+ uint8_t key_[32];
+
+ void FillBuffer();
+};
+
+class MockFramerVisitor : public QuicFramerVisitorInterface {
+ public:
+ MockFramerVisitor();
+ MockFramerVisitor(const MockFramerVisitor&) = delete;
+ MockFramerVisitor& operator=(const MockFramerVisitor&) = delete;
+ ~MockFramerVisitor() override;
+
+ MOCK_METHOD(void, OnError, (QuicFramer*), (override));
+ // The constructor sets this up to return false by default.
+ MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
+ (override));
+ MOCK_METHOD(void, OnPacket, (), (override));
+ MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket& header),
+ (override));
+ MOCK_METHOD(void, OnVersionNegotiationPacket,
+ (const QuicVersionNegotiationPacket& packet), (override));
+ MOCK_METHOD(void, OnRetryPacket,
+ (QuicConnectionId original_connection_id,
+ QuicConnectionId new_connection_id,
+ absl::string_view retry_token,
+ absl::string_view retry_integrity_tag,
+ absl::string_view retry_without_tag),
+ (override));
+ // The constructor sets this up to return true by default.
+ MOCK_METHOD(bool, OnUnauthenticatedHeader, (const QuicPacketHeader& header),
+ (override));
+ // The constructor sets this up to return true by default.
+ MOCK_METHOD(bool, OnUnauthenticatedPublicHeader,
+ (const QuicPacketHeader& header), (override));
+ MOCK_METHOD(void, OnDecryptedPacket, (size_t length, EncryptionLevel level),
+ (override));
+ MOCK_METHOD(bool, OnPacketHeader, (const QuicPacketHeader& header),
+ (override));
+ MOCK_METHOD(void, OnCoalescedPacket, (const QuicEncryptedPacket& packet),
+ (override));
+ MOCK_METHOD(void, OnUndecryptablePacket,
+ (const QuicEncryptedPacket& packet,
+ EncryptionLevel decryption_level, bool has_decryption_key),
+ (override));
+ MOCK_METHOD(bool, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+ MOCK_METHOD(bool, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
+ MOCK_METHOD(bool, OnAckFrameStart, (QuicPacketNumber, QuicTime::Delta),
+ (override));
+ MOCK_METHOD(bool, OnAckRange, (QuicPacketNumber, QuicPacketNumber),
+ (override));
+ MOCK_METHOD(bool, OnAckTimestamp, (QuicPacketNumber, QuicTime), (override));
+ MOCK_METHOD(bool, OnAckFrameEnd, (QuicPacketNumber), (override));
+ MOCK_METHOD(bool, OnStopWaitingFrame, (const QuicStopWaitingFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnPaddingFrame, (const QuicPaddingFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnPingFrame, (const QuicPingFrame& frame), (override));
+ MOCK_METHOD(bool, OnRstStreamFrame, (const QuicRstStreamFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnConnectionCloseFrame,
+ (const QuicConnectionCloseFrame& frame), (override));
+ MOCK_METHOD(bool, OnNewConnectionIdFrame,
+ (const QuicNewConnectionIdFrame& frame), (override));
+ MOCK_METHOD(bool, OnRetireConnectionIdFrame,
+ (const QuicRetireConnectionIdFrame& frame), (override));
+ MOCK_METHOD(bool, OnNewTokenFrame, (const QuicNewTokenFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnPathChallengeFrame, (const QuicPathChallengeFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnGoAwayFrame, (const QuicGoAwayFrame& frame), (override));
+ MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnStreamsBlockedFrame,
+ (const QuicStreamsBlockedFrame& frame), (override));
+ MOCK_METHOD(bool, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnBlockedFrame, (const QuicBlockedFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnMessageFrame, (const QuicMessageFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnHandshakeDoneFrame, (const QuicHandshakeDoneFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnAckFrequencyFrame, (const QuicAckFrequencyFrame& frame),
+ (override));
+ MOCK_METHOD(void, OnPacketComplete, (), (override));
+ MOCK_METHOD(bool, IsValidStatelessResetToken, (const StatelessResetToken&),
+ (const, override));
+ MOCK_METHOD(void, OnAuthenticatedIetfStatelessResetPacket,
+ (const QuicIetfStatelessResetPacket&), (override));
+ MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
+ MOCK_METHOD(void, OnDecryptedFirstPacketInKeyPhase, (), (override));
+ MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
+ AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+ MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
+ (override));
+};
+
+class NoOpFramerVisitor : public QuicFramerVisitorInterface {
+ public:
+ NoOpFramerVisitor() {}
+ NoOpFramerVisitor(const NoOpFramerVisitor&) = delete;
+ NoOpFramerVisitor& operator=(const NoOpFramerVisitor&) = delete;
+
+ void OnError(QuicFramer* /*framer*/) override {}
+ void OnPacket() override {}
+ void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
+ void OnVersionNegotiationPacket(
+ const QuicVersionNegotiationPacket& /*packet*/) override {}
+ void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
+ QuicConnectionId /*new_connection_id*/,
+ absl::string_view /*retry_token*/,
+ absl::string_view /*retry_integrity_tag*/,
+ absl::string_view /*retry_without_tag*/) override {}
+ bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
+ bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
+ bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
+ void OnDecryptedPacket(size_t /*length*/,
+ EncryptionLevel /*level*/) override {}
+ bool OnPacketHeader(const QuicPacketHeader& header) override;
+ void OnCoalescedPacket(const QuicEncryptedPacket& packet) override;
+ void OnUndecryptablePacket(const QuicEncryptedPacket& packet,
+ EncryptionLevel decryption_level,
+ bool has_decryption_key) override;
+ bool OnStreamFrame(const QuicStreamFrame& frame) override;
+ bool OnCryptoFrame(const QuicCryptoFrame& frame) override;
+ bool OnAckFrameStart(QuicPacketNumber largest_acked,
+ QuicTime::Delta ack_delay_time) override;
+ bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override;
+ bool OnAckTimestamp(QuicPacketNumber packet_number,
+ QuicTime timestamp) override;
+ bool OnAckFrameEnd(QuicPacketNumber start) override;
+ bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+ bool OnPaddingFrame(const QuicPaddingFrame& frame) override;
+ bool OnPingFrame(const QuicPingFrame& frame) override;
+ bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
+ bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override;
+ bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override;
+ bool OnRetireConnectionIdFrame(
+ const QuicRetireConnectionIdFrame& frame) override;
+ bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override;
+ bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override;
+ bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override;
+ bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override;
+ bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+ bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override;
+ bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override;
+ bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+ bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+ bool OnMessageFrame(const QuicMessageFrame& frame) override;
+ bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override;
+ bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override;
+ void OnPacketComplete() override {}
+ bool IsValidStatelessResetToken(
+ const StatelessResetToken& token) const override;
+ void OnAuthenticatedIetfStatelessResetPacket(
+ const QuicIetfStatelessResetPacket& /*packet*/) override {}
+ void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
+ void OnDecryptedFirstPacketInKeyPhase() override {}
+ std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
+ override {
+ return nullptr;
+ }
+ std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
+ return nullptr;
+ }
+};
+
+class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
+ public:
+ MockQuicConnectionVisitor();
+ MockQuicConnectionVisitor(const MockQuicConnectionVisitor&) = delete;
+ MockQuicConnectionVisitor& operator=(const MockQuicConnectionVisitor&) =
+ delete;
+ ~MockQuicConnectionVisitor() override;
+
+ MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+ MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
+ MOCK_METHOD(void, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
+ (override));
+ MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame& frame),
+ (override));
+ MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
+ MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
+ MOCK_METHOD(void, OnMessageReceived, (absl::string_view message), (override));
+ MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
+ MOCK_METHOD(void, OnNewTokenReceived, (absl::string_view token), (override));
+ MOCK_METHOD(void, OnConnectionClosed,
+ (const QuicConnectionCloseFrame& frame,
+ ConnectionCloseSource source),
+ (override));
+ MOCK_METHOD(void, OnWriteBlocked, (), (override));
+ MOCK_METHOD(void, OnCanWrite, (), (override));
+ MOCK_METHOD(bool, SendProbingData, (), (override));
+ MOCK_METHOD(bool, ValidateStatelessReset,
+ (const quic::QuicSocketAddress&, const quic::QuicSocketAddress&),
+ (override));
+ MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
+ MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
+ (override));
+ MOCK_METHOD(void, OnPathDegrading, (), (override));
+ MOCK_METHOD(void, OnForwardProgressMadeAfterPathDegrading, (), (override));
+ MOCK_METHOD(bool, WillingAndAbleToWrite, (), (const, override));
+ MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
+ MOCK_METHOD(std::string, GetStreamsInfoForLogging, (), (const, override));
+ MOCK_METHOD(void, OnSuccessfulVersionNegotiation,
+ (const ParsedQuicVersion& version), (override));
+ MOCK_METHOD(void, OnPacketReceived,
+ (const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ bool is_connectivity_probe),
+ (override));
+ MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
+ MOCK_METHOD(void, SendAckFrequency, (const QuicAckFrequencyFrame& frame),
+ (override));
+ MOCK_METHOD(void, SendNewConnectionId,
+ (const QuicNewConnectionIdFrame& frame), (override));
+ MOCK_METHOD(void, SendRetireConnectionId, (uint64_t sequence_number),
+ (override));
+ MOCK_METHOD(void, OnServerConnectionIdIssued,
+ (const QuicConnectionId& server_connection_id), (override));
+ MOCK_METHOD(void, OnServerConnectionIdRetired,
+ (const QuicConnectionId& server_connection_id), (override));
+ MOCK_METHOD(bool, AllowSelfAddressChange, (), (const, override));
+ MOCK_METHOD(HandshakeState, GetHandshakeState, (), (const, override));
+ MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
+ (override));
+ MOCK_METHOD(bool, OnStreamsBlockedFrame,
+ (const QuicStreamsBlockedFrame& frame), (override));
+ MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
+ (override));
+ MOCK_METHOD(void, OnPacketDecrypted, (EncryptionLevel), (override));
+ MOCK_METHOD(void, OnOneRttPacketAcknowledged, (), (override));
+ MOCK_METHOD(void, OnHandshakePacketSent, (), (override));
+ MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
+ MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
+ AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+ MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
+ (override));
+ MOCK_METHOD(void, BeforeConnectionCloseSent, (), (override));
+ MOCK_METHOD(bool, ValidateToken, (absl::string_view), (override));
+ MOCK_METHOD(bool, MaybeSendAddressToken, (), (override));
+
+ bool IsKnownServerAddress(
+ const QuicSocketAddress& /*address*/) const override {
+ return false;
+ }
+};
+
+class MockQuicConnectionHelper : public QuicConnectionHelperInterface {
+ public:
+ MockQuicConnectionHelper();
+ MockQuicConnectionHelper(const MockQuicConnectionHelper&) = delete;
+ MockQuicConnectionHelper& operator=(const MockQuicConnectionHelper&) = delete;
+ ~MockQuicConnectionHelper() override;
+ const QuicClock* GetClock() const override;
+ QuicRandom* GetRandomGenerator() override;
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
+ void AdvanceTime(QuicTime::Delta delta);
+
+ private:
+ MockClock clock_;
+ MockRandom random_generator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
+};
+
+class MockAlarmFactory : public QuicAlarmFactory {
+ public:
+ QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
+ QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+ QuicConnectionArena* arena) override;
+
+ // No-op alarm implementation
+ class TestAlarm : public QuicAlarm {
+ public:
+ explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+ : QuicAlarm(std::move(delegate)) {}
+
+ void SetImpl() override {}
+ void CancelImpl() override {}
+
+ using QuicAlarm::Fire;
+ };
+
+ void FireAlarm(QuicAlarm* alarm) {
+ reinterpret_cast<TestAlarm*>(alarm)->Fire();
+ }
+};
+
+class TestAlarmFactory : public QuicAlarmFactory {
+ public:
+ class TestAlarm : public QuicAlarm {
+ public:
+ explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+ : QuicAlarm(std::move(delegate)) {}
+
+ void SetImpl() override {}
+ void CancelImpl() override {}
+ using QuicAlarm::Fire;
+ };
+
+ TestAlarmFactory() {}
+ TestAlarmFactory(const TestAlarmFactory&) = delete;
+ TestAlarmFactory& operator=(const TestAlarmFactory&) = delete;
+
+ QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
+ return new TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+ }
+
+ QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+ QuicConnectionArena* arena) override {
+ return arena->New<TestAlarm>(std::move(delegate));
+ }
+};
+
+class MockQuicConnection : public QuicConnection {
+ public:
+ // Uses a ConnectionId of 42 and 127.0.0.1:123.
+ MockQuicConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory, Perspective perspective);
+
+ // Uses a ConnectionId of 42.
+ MockQuicConnection(QuicSocketAddress address,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory, Perspective perspective);
+
+ // Uses 127.0.0.1:123.
+ MockQuicConnection(QuicConnectionId connection_id,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory, Perspective perspective);
+
+ // Uses a ConnectionId of 42, and 127.0.0.1:123.
+ MockQuicConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory, Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions);
+
+ MockQuicConnection(QuicConnectionId connection_id, QuicSocketAddress address,
+ MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory, Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions);
+ MockQuicConnection(const MockQuicConnection&) = delete;
+ MockQuicConnection& operator=(const MockQuicConnection&) = delete;
+
+ ~MockQuicConnection() override;
+
+ // If the constructor that uses a MockQuicConnectionHelper has been used then
+ // this method
+ // will advance the time of the MockClock.
+ void AdvanceTime(QuicTime::Delta delta);
+
+ MOCK_METHOD(void, ProcessUdpPacket,
+ (const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ const QuicReceivedPacket& packet),
+ (override));
+ MOCK_METHOD(void, CloseConnection,
+ (QuicErrorCode error, const std::string& details,
+ ConnectionCloseBehavior connection_close_behavior),
+ (override));
+ MOCK_METHOD(void, CloseConnection,
+ (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
+ const std::string& details,
+ ConnectionCloseBehavior connection_close_behavior),
+ (override));
+ MOCK_METHOD(void, SendConnectionClosePacket,
+ (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
+ const std::string& details),
+ (override));
+ MOCK_METHOD(void, OnCanWrite, (), (override));
+ MOCK_METHOD(bool, SendConnectivityProbingPacket,
+ (QuicPacketWriter*, const QuicSocketAddress& peer_address),
+ (override));
+
+ MOCK_METHOD(void, OnSendConnectionState, (const CachedNetworkParameters&),
+ (override));
+ MOCK_METHOD(void, ResumeConnectionState,
+ (const CachedNetworkParameters&, bool), (override));
+ MOCK_METHOD(void, SetMaxPacingRate, (QuicBandwidth), (override));
+
+ MOCK_METHOD(void, OnStreamReset, (QuicStreamId, QuicRstStreamErrorCode),
+ (override));
+ MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
+ MOCK_METHOD(MessageStatus, SendMessage,
+ (QuicMessageId, absl::Span<quiche::QuicheMemSlice>, bool),
+ (override));
+ MOCK_METHOD(bool, SendPathChallenge,
+ (const QuicPathFrameBuffer&, const QuicSocketAddress&,
+ const QuicSocketAddress&, const QuicSocketAddress&,
+ QuicPacketWriter*),
+ (override));
+
+ MOCK_METHOD(void, OnError, (QuicFramer*), (override));
+ void QuicConnection_OnError(QuicFramer* framer) {
+ QuicConnection::OnError(framer);
+ }
+
+ void ReallyOnCanWrite() { QuicConnection::OnCanWrite(); }
+
+ void ReallyCloseConnection(
+ QuicErrorCode error, const std::string& details,
+ ConnectionCloseBehavior connection_close_behavior) {
+ // Call the 4-param method directly instead of the 3-param method, so that
+ // it doesn't invoke the virtual 4-param method causing the mock 4-param
+ // method to trigger.
+ QuicConnection::CloseConnection(error, NO_IETF_QUIC_ERROR, details,
+ connection_close_behavior);
+ }
+
+ void ReallyCloseConnection4(
+ QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
+ const std::string& details,
+ ConnectionCloseBehavior connection_close_behavior) {
+ QuicConnection::CloseConnection(error, ietf_error, details,
+ connection_close_behavior);
+ }
+
+ void ReallySendConnectionClosePacket(QuicErrorCode error,
+ QuicIetfTransportErrorCodes ietf_error,
+ const std::string& details) {
+ QuicConnection::SendConnectionClosePacket(error, ietf_error, details);
+ }
+
+ void ReallyProcessUdpPacket(const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ const QuicReceivedPacket& packet) {
+ QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
+ }
+
+ bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
+
+ bool ReallySendControlFrame(const QuicFrame& frame) {
+ return QuicConnection::SendControlFrame(frame);
+ }
+
+ bool ReallySendConnectivityProbingPacket(
+ QuicPacketWriter* probing_writer, const QuicSocketAddress& peer_address) {
+ return QuicConnection::SendConnectivityProbingPacket(probing_writer,
+ peer_address);
+ }
+
+ bool ReallyOnPathResponseFrame(const QuicPathResponseFrame& frame) {
+ return QuicConnection::OnPathResponseFrame(frame);
+ }
+
+ MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame&),
+ (override));
+ MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
+ (override));
+ MOCK_METHOD(size_t, SendCryptoData,
+ (EncryptionLevel, size_t, QuicStreamOffset), (override));
+ size_t QuicConnection_SendCryptoData(EncryptionLevel level,
+ size_t write_length,
+ QuicStreamOffset offset) {
+ return QuicConnection::SendCryptoData(level, write_length, offset);
+ }
+};
+
+class PacketSavingConnection : public MockQuicConnection {
+ public:
+ PacketSavingConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective);
+
+ PacketSavingConnection(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective,
+ const ParsedQuicVersionVector& supported_versions);
+ PacketSavingConnection(const PacketSavingConnection&) = delete;
+ PacketSavingConnection& operator=(const PacketSavingConnection&) = delete;
+
+ ~PacketSavingConnection() override;
+
+ void SendOrQueuePacket(SerializedPacket packet) override;
+
+ MOCK_METHOD(void, OnPacketSent, (EncryptionLevel, TransmissionType));
+
+ std::vector<std::unique_ptr<QuicEncryptedPacket>> encrypted_packets_;
+ // Number of packets in encrypted_packets that has been delivered to the peer
+ // connection.
+ size_t number_of_packets_delivered_ = 0;
+ MockClock clock_;
+};
+
+class MockQuicSession : public QuicSession {
+ public:
+ // Takes ownership of |connection|.
+ MockQuicSession(QuicConnection* connection, bool create_mock_crypto_stream);
+
+ // Takes ownership of |connection|.
+ explicit MockQuicSession(QuicConnection* connection);
+ MockQuicSession(const MockQuicSession&) = delete;
+ MockQuicSession& operator=(const MockQuicSession&) = delete;
+ ~MockQuicSession() override;
+
+ QuicCryptoStream* GetMutableCryptoStream() override;
+ const QuicCryptoStream* GetCryptoStream() const override;
+ void SetCryptoStream(QuicCryptoStream* crypto_stream);
+
+ MOCK_METHOD(void, OnConnectionClosed,
+ (const QuicConnectionCloseFrame& frame,
+ ConnectionCloseSource source),
+ (override));
+ MOCK_METHOD(QuicStream*, CreateIncomingStream, (QuicStreamId id), (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
+ (override));
+ MOCK_METHOD(QuicConsumedData, WritevData,
+ (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType type,
+ EncryptionLevel level),
+ (override));
+ MOCK_METHOD(bool, WriteControlFrame,
+ (const QuicFrame& frame, TransmissionType type), (override));
+ MOCK_METHOD(void, MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id, QuicResetStreamError error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void, MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicResetStreamError error), (override));
+
+ MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
+ MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
+ MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+ (const std::vector<absl::string_view>&), (const, override));
+ MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
+
+ using QuicSession::ActivateStream;
+
+ // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
+ // if set) has been consumed.
+ QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType type,
+ absl::optional<EncryptionLevel> level);
+
+ void ReallyMaybeSendRstStreamFrame(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written) {
+ QuicSession::MaybeSendRstStreamFrame(
+ id, QuicResetStreamError::FromInternal(error), bytes_written);
+ }
+
+ private:
+ std::unique_ptr<QuicCryptoStream> crypto_stream_;
+};
+
+class MockQuicCryptoStream : public QuicCryptoStream {
+ public:
+ explicit MockQuicCryptoStream(QuicSession* session);
+
+ ~MockQuicCryptoStream() override;
+
+ ssl_early_data_reason_t EarlyDataReason() const override;
+ bool encryption_established() const override;
+ bool one_rtt_keys_available() const override;
+ const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
+ const override;
+ CryptoMessageParser* crypto_message_parser() override;
+ void OnPacketDecrypted(EncryptionLevel /*level*/) override {}
+ void OnOneRttPacketAcknowledged() override {}
+ void OnHandshakePacketSent() override {}
+ void OnHandshakeDoneReceived() override {}
+ void OnNewTokenReceived(absl::string_view /*token*/) override {}
+ std::string GetAddressToken(
+ const CachedNetworkParameters* /*cached_network_parameters*/)
+ const override {
+ return "";
+ }
+ bool ValidateAddressToken(absl::string_view /*token*/) const override {
+ return true;
+ }
+ const CachedNetworkParameters* PreviousCachedNetworkParams() const override {
+ return nullptr;
+ }
+ void SetPreviousCachedNetworkParams(
+ CachedNetworkParameters /*cached_network_params*/) override {}
+ void OnConnectionClosed(QuicErrorCode /*error*/,
+ ConnectionCloseSource /*source*/) override {}
+ HandshakeState GetHandshakeState() const override { return HANDSHAKE_START; }
+ void SetServerApplicationStateForResumption(
+ std::unique_ptr<ApplicationState> /*application_state*/) override {}
+ std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
+ override {
+ return nullptr;
+ }
+ std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
+ return nullptr;
+ }
+ bool ExportKeyingMaterial(absl::string_view /*label*/,
+ absl::string_view /*context*/,
+ size_t /*result_len*/,
+ std::string* /*result*/) override {
+ return false;
+ }
+ SSL* GetSsl() const override { return nullptr; }
+
+ private:
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ CryptoFramer crypto_framer_;
+};
+
+class MockQuicSpdySession : public QuicSpdySession {
+ public:
+ // Takes ownership of |connection|.
+ explicit MockQuicSpdySession(QuicConnection* connection);
+ // Takes ownership of |connection|.
+ MockQuicSpdySession(QuicConnection* connection,
+ bool create_mock_crypto_stream);
+ MockQuicSpdySession(const MockQuicSpdySession&) = delete;
+ MockQuicSpdySession& operator=(const MockQuicSpdySession&) = delete;
+ ~MockQuicSpdySession() override;
+
+ QuicCryptoStream* GetMutableCryptoStream() override;
+ const QuicCryptoStream* GetCryptoStream() const override;
+ void SetCryptoStream(QuicCryptoStream* crypto_stream);
+
+ void ReallyOnConnectionClosed(const QuicConnectionCloseFrame& frame,
+ ConnectionCloseSource source) {
+ QuicSession::OnConnectionClosed(frame, source);
+ }
+
+ // From QuicSession.
+ MOCK_METHOD(void, OnConnectionClosed,
+ (const QuicConnectionCloseFrame& frame,
+ ConnectionCloseSource source),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
+ (override));
+ MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
+ MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
+ MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
+ MOCK_METHOD(QuicConsumedData, WritevData,
+ (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType type,
+ EncryptionLevel level),
+ (override));
+ MOCK_METHOD(void, MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id, QuicResetStreamError error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void, MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicResetStreamError error), (override));
+ MOCK_METHOD(void, SendWindowUpdate,
+ (QuicStreamId id, QuicStreamOffset byte_offset), (override));
+ MOCK_METHOD(void, SendBlocked, (QuicStreamId id), (override));
+ MOCK_METHOD(void, OnStreamHeadersPriority,
+ (QuicStreamId stream_id,
+ const spdy::SpdyStreamPrecedence& precedence),
+ (override));
+ MOCK_METHOD(void, OnStreamHeaderList,
+ (QuicStreamId stream_id, bool fin, size_t frame_len,
+ const QuicHeaderList& header_list),
+ (override));
+ MOCK_METHOD(void, OnPromiseHeaderList,
+ (QuicStreamId stream_id, QuicStreamId promised_stream_id,
+ size_t frame_len, const QuicHeaderList& header_list),
+ (override));
+ MOCK_METHOD(void, OnPriorityFrame,
+ (QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
+ (override));
+ MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
+
+ // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
+ // if set) has been consumed.
+ QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType type,
+ absl::optional<EncryptionLevel> level);
+
+ using QuicSession::ActivateStream;
+
+ private:
+ std::unique_ptr<QuicCryptoStream> crypto_stream_;
+};
+
+class MockHttp3DebugVisitor : public Http3DebugVisitor {
+ public:
+ MOCK_METHOD(void, OnControlStreamCreated, (QuicStreamId), (override));
+ MOCK_METHOD(void, OnQpackEncoderStreamCreated, (QuicStreamId), (override));
+ MOCK_METHOD(void, OnQpackDecoderStreamCreated, (QuicStreamId), (override));
+ MOCK_METHOD(void, OnPeerControlStreamCreated, (QuicStreamId), (override));
+ MOCK_METHOD(void, OnPeerQpackEncoderStreamCreated, (QuicStreamId),
+ (override));
+ MOCK_METHOD(void, OnPeerQpackDecoderStreamCreated, (QuicStreamId),
+ (override));
+
+ MOCK_METHOD(void, OnSettingsFrameReceivedViaAlps, (const SettingsFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnAcceptChFrameReceivedViaAlps, (const AcceptChFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnSettingsFrameReceived, (const SettingsFrame&),
+ (override));
+ MOCK_METHOD(void, OnGoAwayFrameReceived, (const GoAwayFrame&), (override));
+ MOCK_METHOD(void, OnMaxPushIdFrameReceived, (const MaxPushIdFrame&),
+ (override));
+ MOCK_METHOD(void, OnPriorityUpdateFrameReceived, (const PriorityUpdateFrame&),
+ (override));
+ MOCK_METHOD(void, OnAcceptChFrameReceived, (const AcceptChFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnDataFrameReceived, (QuicStreamId, QuicByteCount),
+ (override));
+ MOCK_METHOD(void, OnHeadersFrameReceived, (QuicStreamId, QuicByteCount),
+ (override));
+ MOCK_METHOD(void, OnHeadersDecoded, (QuicStreamId, QuicHeaderList),
+ (override));
+ MOCK_METHOD(void, OnUnknownFrameReceived,
+ (QuicStreamId, uint64_t, QuicByteCount), (override));
+
+ MOCK_METHOD(void, OnSettingsFrameSent, (const SettingsFrame&), (override));
+ MOCK_METHOD(void, OnGoAwayFrameSent, (QuicStreamId), (override));
+ MOCK_METHOD(void, OnPriorityUpdateFrameSent, (const PriorityUpdateFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
+ MOCK_METHOD(void, OnHeadersFrameSent,
+ (QuicStreamId, const spdy::SpdyHeaderBlock&), (override));
+};
+
+class TestQuicSpdyServerSession : public QuicServerSessionBase {
+ public:
+ // Takes ownership of |connection|.
+ TestQuicSpdyServerSession(QuicConnection* connection,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache);
+ TestQuicSpdyServerSession(const TestQuicSpdyServerSession&) = delete;
+ TestQuicSpdyServerSession& operator=(const TestQuicSpdyServerSession&) =
+ delete;
+ ~TestQuicSpdyServerSession() override;
+
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
+ (override));
+ MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+ (const std::vector<absl::string_view>&), (const, override));
+ MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
+ std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
+ const QuicCryptoServerConfig* crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache) override;
+
+ QuicCryptoServerStreamBase* GetMutableCryptoStream() override;
+
+ const QuicCryptoServerStreamBase* GetCryptoStream() const override;
+
+ MockQuicCryptoServerStreamHelper* helper() { return &helper_; }
+
+ QuicSSLConfig GetSSLConfig() const override {
+ QuicSSLConfig ssl_config = QuicServerSessionBase::GetSSLConfig();
+ if (early_data_enabled_.has_value()) {
+ ssl_config.early_data_enabled = *early_data_enabled_;
+ }
+ if (client_cert_mode_.has_value()) {
+ ssl_config.client_cert_mode = *client_cert_mode_;
+ }
+
+ return ssl_config;
+ }
+
+ void set_early_data_enabled(bool enabled) { early_data_enabled_ = enabled; }
+
+ void set_client_cert_mode(ClientCertMode mode) {
+ if (support_client_cert()) {
+ client_cert_mode_ = mode;
+ }
+ }
+
+ private:
+ MockQuicSessionVisitor visitor_;
+ MockQuicCryptoServerStreamHelper helper_;
+ // If not nullopt, override the early_data_enabled value from base class'
+ // ssl_config.
+ absl::optional<bool> early_data_enabled_;
+ // If not nullopt, override the client_cert_mode value from base class'
+ // ssl_config.
+ absl::optional<ClientCertMode> client_cert_mode_;
+};
+
+// A test implementation of QuicClientPushPromiseIndex::Delegate.
+class TestPushPromiseDelegate : public QuicClientPushPromiseIndex::Delegate {
+ public:
+ // |match| sets the validation result for checking whether designated header
+ // fields match for promise request and client request.
+ explicit TestPushPromiseDelegate(bool match);
+
+ bool CheckVary(const spdy::SpdyHeaderBlock& client_request,
+ const spdy::SpdyHeaderBlock& promise_request,
+ const spdy::SpdyHeaderBlock& promise_response) override;
+
+ void OnRendezvousResult(QuicSpdyStream* stream) override;
+
+ QuicSpdyStream* rendezvous_stream() { return rendezvous_stream_; }
+ bool rendezvous_fired() { return rendezvous_fired_; }
+
+ private:
+ bool match_;
+ bool rendezvous_fired_;
+ QuicSpdyStream* rendezvous_stream_;
+};
+
+class TestQuicSpdyClientSession : public QuicSpdyClientSessionBase {
+ public:
+ TestQuicSpdyClientSession(QuicConnection* connection,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions,
+ const QuicServerId& server_id,
+ QuicCryptoClientConfig* crypto_config);
+ TestQuicSpdyClientSession(const TestQuicSpdyClientSession&) = delete;
+ TestQuicSpdyClientSession& operator=(const TestQuicSpdyClientSession&) =
+ delete;
+ ~TestQuicSpdyClientSession() override;
+
+ bool IsAuthorized(const std::string& authority) override;
+
+ // QuicSpdyClientSessionBase
+ MOCK_METHOD(void, OnProofValid,
+ (const QuicCryptoClientConfig::CachedState& cached), (override));
+ MOCK_METHOD(void, OnProofVerifyDetailsAvailable,
+ (const ProofVerifyDetails& verify_details), (override));
+
+ // TestQuicSpdyClientSession
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
+ (override));
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
+ (override));
+ MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
+ MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
+ MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
+ MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
+ MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
+ MOCK_METHOD(void, OnConfigNegotiated, (), (override));
+
+ QuicCryptoClientStream* GetMutableCryptoStream() override;
+ const QuicCryptoClientStream* GetCryptoStream() const override;
+
+ // Override to save sent crypto handshake messages.
+ void OnCryptoHandshakeMessageSent(
+ const CryptoHandshakeMessage& message) override {
+ sent_crypto_handshake_messages_.push_back(message);
+ }
+
+ const std::vector<CryptoHandshakeMessage>& sent_crypto_handshake_messages()
+ const {
+ return sent_crypto_handshake_messages_;
+ }
+
+ private:
+ // Calls the parent class's OnConfigNegotiated method. Used to set the default
+ // mock behavior for OnConfigNegotiated.
+ void RealOnConfigNegotiated();
+
+ std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
+ QuicClientPushPromiseIndex push_promise_index_;
+ std::vector<CryptoHandshakeMessage> sent_crypto_handshake_messages_;
+};
+
+class MockPacketWriter : public QuicPacketWriter {
+ public:
+ MockPacketWriter();
+ MockPacketWriter(const MockPacketWriter&) = delete;
+ MockPacketWriter& operator=(const MockPacketWriter&) = delete;
+ ~MockPacketWriter() override;
+
+ MOCK_METHOD(WriteResult, WritePacket,
+ (const char*, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions*),
+ (override));
+ MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
+ MOCK_METHOD(void, SetWritable, (), (override));
+ MOCK_METHOD(absl::optional<int>, MessageTooBigErrorCode, (),
+ (const, override));
+ MOCK_METHOD(QuicByteCount, GetMaxPacketSize,
+ (const QuicSocketAddress& peer_address), (const, override));
+ MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
+ MOCK_METHOD(bool, IsBatchMode, (), (const, override));
+ MOCK_METHOD(QuicPacketBuffer, GetNextWriteLocation,
+ (const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address),
+ (override));
+ MOCK_METHOD(WriteResult, Flush, (), (override));
+};
+
+class MockSendAlgorithm : public SendAlgorithmInterface {
+ public:
+ MockSendAlgorithm();
+ MockSendAlgorithm(const MockSendAlgorithm&) = delete;
+ MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete;
+ ~MockSendAlgorithm() override;
+
+ MOCK_METHOD(void, SetFromConfig,
+ (const QuicConfig& config, Perspective perspective), (override));
+ MOCK_METHOD(void, ApplyConnectionOptions,
+ (const QuicTagVector& connection_options), (override));
+ MOCK_METHOD(void, SetInitialCongestionWindowInPackets,
+ (QuicPacketCount packets), (override));
+ MOCK_METHOD(void, OnCongestionEvent,
+ (bool rtt_updated, QuicByteCount bytes_in_flight,
+ QuicTime event_time, const AckedPacketVector& acked_packets,
+ const LostPacketVector& lost_packets),
+ (override));
+ MOCK_METHOD(void, OnPacketSent,
+ (QuicTime, QuicByteCount, QuicPacketNumber, QuicByteCount,
+ HasRetransmittableData),
+ (override));
+ MOCK_METHOD(void, OnPacketNeutered, (QuicPacketNumber), (override));
+ MOCK_METHOD(void, OnRetransmissionTimeout, (bool), (override));
+ MOCK_METHOD(void, OnConnectionMigration, (), (override));
+ MOCK_METHOD(bool, CanSend, (QuicByteCount), (override));
+ MOCK_METHOD(QuicBandwidth, PacingRate, (QuicByteCount), (const, override));
+ MOCK_METHOD(QuicBandwidth, BandwidthEstimate, (), (const, override));
+ MOCK_METHOD(bool, HasGoodBandwidthEstimateForResumption, (),
+ (const, override));
+ MOCK_METHOD(QuicByteCount, GetCongestionWindow, (), (const, override));
+ MOCK_METHOD(std::string, GetDebugState, (), (const, override));
+ MOCK_METHOD(bool, InSlowStart, (), (const, override));
+ MOCK_METHOD(bool, InRecovery, (), (const, override));
+ MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
+ MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
+ MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
+ (const, override));
+ MOCK_METHOD(void, AdjustNetworkParameters, (const NetworkParams&),
+ (override));
+ MOCK_METHOD(void, OnApplicationLimited, (QuicByteCount), (override));
+ MOCK_METHOD(void, PopulateConnectionStats, (QuicConnectionStats*),
+ (const, override));
+};
+
+class MockLossAlgorithm : public LossDetectionInterface {
+ public:
+ MockLossAlgorithm();
+ MockLossAlgorithm(const MockLossAlgorithm&) = delete;
+ MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete;
+ ~MockLossAlgorithm() override;
+
+ MOCK_METHOD(void, SetFromConfig,
+ (const QuicConfig& config, Perspective perspective), (override));
+
+ MOCK_METHOD(DetectionStats, DetectLosses,
+ (const QuicUnackedPacketMap& unacked_packets, QuicTime time,
+ const RttStats& rtt_stats,
+ QuicPacketNumber largest_recently_acked,
+ const AckedPacketVector& packets_acked, LostPacketVector*),
+ (override));
+ MOCK_METHOD(QuicTime, GetLossTimeout, (), (const, override));
+ MOCK_METHOD(void, SpuriousLossDetected,
+ (const QuicUnackedPacketMap&, const RttStats&, QuicTime,
+ QuicPacketNumber, QuicPacketNumber),
+ (override));
+
+ MOCK_METHOD(void, OnConfigNegotiated, (), (override));
+ MOCK_METHOD(void, OnMinRttAvailable, (), (override));
+ MOCK_METHOD(void, OnUserAgentIdKnown, (), (override));
+ MOCK_METHOD(void, OnConnectionClosed, (), (override));
+ MOCK_METHOD(void, OnReorderingDetected, (), (override));
+};
+
+class MockAckListener : public QuicAckListenerInterface {
+ public:
+ MockAckListener();
+ MockAckListener(const MockAckListener&) = delete;
+ MockAckListener& operator=(const MockAckListener&) = delete;
+
+ MOCK_METHOD(void, OnPacketAcked,
+ (int acked_bytes, QuicTime::Delta ack_delay_time), (override));
+
+ MOCK_METHOD(void, OnPacketRetransmitted, (int retransmitted_bytes),
+ (override));
+
+ protected:
+ // Object is ref counted.
+ ~MockAckListener() override;
+};
+
+class MockNetworkChangeVisitor
+ : public QuicSentPacketManager::NetworkChangeVisitor {
+ public:
+ MockNetworkChangeVisitor();
+ MockNetworkChangeVisitor(const MockNetworkChangeVisitor&) = delete;
+ MockNetworkChangeVisitor& operator=(const MockNetworkChangeVisitor&) = delete;
+ ~MockNetworkChangeVisitor() override;
+
+ MOCK_METHOD(void, OnCongestionChange, (), (override));
+ MOCK_METHOD(void, OnPathMtuIncreased, (QuicPacketLength), (override));
+};
+
+class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
+ public:
+ MockQuicConnectionDebugVisitor();
+ ~MockQuicConnectionDebugVisitor() override;
+
+ MOCK_METHOD(void, OnPacketSent,
+ (QuicPacketNumber, QuicPacketLength, bool, TransmissionType,
+ EncryptionLevel, const QuicFrames&, const QuicFrames&, QuicTime),
+ (override));
+
+ MOCK_METHOD(void, OnCoalescedPacketSent, (const QuicCoalescedPacket&, size_t),
+ (override));
+
+ MOCK_METHOD(void, OnPingSent, (), (override));
+
+ MOCK_METHOD(void, OnPacketReceived,
+ (const QuicSocketAddress&, const QuicSocketAddress&,
+ const QuicEncryptedPacket&),
+ (override));
+
+ MOCK_METHOD(void, OnIncorrectConnectionId, (QuicConnectionId), (override));
+
+ MOCK_METHOD(void, OnProtocolVersionMismatch, (ParsedQuicVersion), (override));
+
+ MOCK_METHOD(void, OnPacketHeader,
+ (const QuicPacketHeader& header, QuicTime receive_time,
+ EncryptionLevel level),
+ (override));
+
+ MOCK_METHOD(void, OnSuccessfulVersionNegotiation, (const ParsedQuicVersion&),
+ (override));
+
+ MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame&), (override));
+
+ MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
+
+ MOCK_METHOD(void, OnStopWaitingFrame, (const QuicStopWaitingFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
+
+ MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame&), (override));
+
+ MOCK_METHOD(void, OnNewConnectionIdFrame, (const QuicNewConnectionIdFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnRetireConnectionIdFrame,
+ (const QuicRetireConnectionIdFrame&), (override));
+
+ MOCK_METHOD(void, OnNewTokenFrame, (const QuicNewTokenFrame&), (override));
+
+ MOCK_METHOD(void, OnMessageFrame, (const QuicMessageFrame&), (override));
+
+ MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnPathChallengeFrame, (const QuicPathChallengeFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
+ (override));
+
+ MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket&),
+ (override));
+
+ MOCK_METHOD(void, OnVersionNegotiationPacket,
+ (const QuicVersionNegotiationPacket&), (override));
+
+ MOCK_METHOD(void, OnTransportParametersSent, (const TransportParameters&),
+ (override));
+
+ MOCK_METHOD(void, OnTransportParametersReceived, (const TransportParameters&),
+ (override));
+
+ MOCK_METHOD(void, OnZeroRttRejected, (int), (override));
+ MOCK_METHOD(void, OnZeroRttPacketAcked, (), (override));
+};
+
+class MockReceivedPacketManager : public QuicReceivedPacketManager {
+ public:
+ explicit MockReceivedPacketManager(QuicConnectionStats* stats);
+ ~MockReceivedPacketManager() override;
+
+ MOCK_METHOD(void, RecordPacketReceived,
+ (const QuicPacketHeader& header, QuicTime receipt_time),
+ (override));
+ MOCK_METHOD(bool, IsMissing, (QuicPacketNumber packet_number), (override));
+ MOCK_METHOD(bool, IsAwaitingPacket, (QuicPacketNumber packet_number),
+ (const, override));
+ MOCK_METHOD(bool, HasNewMissingPackets, (), (const, override));
+ MOCK_METHOD(bool, ack_frame_updated, (), (const, override));
+};
+
+class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface {
+ public:
+ MockPacketCreatorDelegate();
+ MockPacketCreatorDelegate(const MockPacketCreatorDelegate&) = delete;
+ MockPacketCreatorDelegate& operator=(const MockPacketCreatorDelegate&) =
+ delete;
+ ~MockPacketCreatorDelegate() override;
+
+ MOCK_METHOD(QuicPacketBuffer, GetPacketBuffer, (), (override));
+ MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket), (override));
+ MOCK_METHOD(void, OnUnrecoverableError, (QuicErrorCode, const std::string&),
+ (override));
+ MOCK_METHOD(bool, ShouldGeneratePacket,
+ (HasRetransmittableData retransmittable, IsHandshake handshake),
+ (override));
+ MOCK_METHOD(const QuicFrames, MaybeBundleAckOpportunistically, (),
+ (override));
+ MOCK_METHOD(SerializedPacketFate, GetSerializedPacketFate,
+ (bool, EncryptionLevel), (override));
+};
+
+class MockSessionNotifier : public SessionNotifierInterface {
+ public:
+ MockSessionNotifier();
+ ~MockSessionNotifier() override;
+
+ MOCK_METHOD(bool, OnFrameAcked, (const QuicFrame&, QuicTime::Delta, QuicTime),
+ (override));
+ MOCK_METHOD(void, OnStreamFrameRetransmitted, (const QuicStreamFrame&),
+ (override));
+ MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
+ MOCK_METHOD(bool, RetransmitFrames,
+ (const QuicFrames&, TransmissionType type), (override));
+ MOCK_METHOD(bool, IsFrameOutstanding, (const QuicFrame&), (const, override));
+ MOCK_METHOD(bool, HasUnackedCryptoData, (), (const, override));
+ MOCK_METHOD(bool, HasUnackedStreamData, (), (const, override));
+};
+
+class MockQuicPathValidationContext : public QuicPathValidationContext {
+ public:
+ MockQuicPathValidationContext(const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ const QuicSocketAddress& effective_peer_address,
+ QuicPacketWriter* writer)
+ : QuicPathValidationContext(self_address, peer_address,
+ effective_peer_address),
+ writer_(writer) {}
+ QuicPacketWriter* WriterToUse() override { return writer_; }
+
+ private:
+ QuicPacketWriter* writer_;
+};
+
+class MockQuicPathValidationResultDelegate
+ : public QuicPathValidator::ResultDelegate {
+ public:
+ MOCK_METHOD(void, OnPathValidationSuccess,
+ (std::unique_ptr<QuicPathValidationContext>), (override));
+
+ MOCK_METHOD(void, OnPathValidationFailure,
+ (std::unique_ptr<QuicPathValidationContext>), (override));
+};
+
+class QuicCryptoClientStreamPeer {
+ public:
+ QuicCryptoClientStreamPeer() = delete;
+
+ static QuicCryptoClientStream::HandshakerInterface* GetHandshaker(
+ QuicCryptoClientStream* stream);
+};
+
+// Creates a client session for testing.
+//
+// server_id: The server id associated with this stream.
+// connection_start_time: The time to set for the connection clock.
+// Needed for strike-register nonce verification. The client
+// connection_start_time should be synchronized witht the server
+// start time, otherwise nonce verification will fail.
+// supported_versions: Set of QUIC versions this client supports.
+// helper: Pointer to the MockQuicConnectionHelper to use for the session.
+// crypto_client_config: Pointer to the crypto client config.
+// client_connection: Pointer reference for newly created
+// connection. This object will be owned by the
+// client_session.
+// client_session: Pointer reference for the newly created client
+// session. The new object will be owned by the caller.
+void CreateClientSessionForTest(
+ QuicServerId server_id, QuicTime::Delta connection_start_time,
+ const ParsedQuicVersionVector& supported_versions,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
+ QuicCryptoClientConfig* crypto_client_config,
+ PacketSavingConnection** client_connection,
+ TestQuicSpdyClientSession** client_session);
+
+// Creates a server session for testing.
+//
+// server_id: The server id associated with this stream.
+// connection_start_time: The time to set for the connection clock.
+// Needed for strike-register nonce verification. The server
+// connection_start_time should be synchronized witht the client
+// start time, otherwise nonce verification will fail.
+// supported_versions: Set of QUIC versions this server supports.
+// helper: Pointer to the MockQuicConnectionHelper to use for the session.
+// server_crypto_config: Pointer to the crypto server config.
+// server_connection: Pointer reference for newly created
+// connection. This object will be owned by the
+// server_session.
+// server_session: Pointer reference for the newly created server
+// session. The new object will be owned by the caller.
+void CreateServerSessionForTest(
+ QuicServerId server_id, QuicTime::Delta connection_start_time,
+ ParsedQuicVersionVector supported_versions,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
+ QuicCryptoServerConfig* server_crypto_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ PacketSavingConnection** server_connection,
+ TestQuicSpdyServerSession** server_session);
+
+// Verifies that the relative error of |actual| with respect to |expected| is
+// no more than |margin|.
+// Please use EXPECT_APPROX_EQ, a wrapper around this function, for better error
+// report.
+template <typename T>
+void ExpectApproxEq(T expected, T actual, float relative_margin) {
+ // If |relative_margin| > 1 and T is an unsigned type, the comparison will
+ // underflow.
+ ASSERT_LE(relative_margin, 1);
+ ASSERT_GE(relative_margin, 0);
+
+ T absolute_margin = expected * relative_margin;
+
+ EXPECT_GE(expected + absolute_margin, actual) << "actual value too big";
+ EXPECT_LE(expected - absolute_margin, actual) << "actual value too small";
+}
+
+#define EXPECT_APPROX_EQ(expected, actual, relative_margin) \
+ do { \
+ SCOPED_TRACE(testing::Message() << "relative_margin:" << relative_margin); \
+ quic::test::ExpectApproxEq(expected, actual, relative_margin); \
+ } while (0)
+
+template <typename T>
+QuicHeaderList AsHeaderList(const T& container) {
+ QuicHeaderList l;
+ l.OnHeaderBlockStart();
+ size_t total_size = 0;
+ for (auto p : container) {
+ total_size += p.first.size() + p.second.size();
+ l.OnHeader(p.first, p.second);
+ }
+ l.OnHeaderBlockEnd(total_size, total_size);
+ return l;
+}
+
+// Helper functions for stream ids, to allow test logic to abstract over the
+// HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used
+// per HTTP transaction).
+QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
+ QuicTransportVersion version, int n);
+QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
+ QuicTransportVersion version, int n);
+QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
+ QuicTransportVersion version, int n);
+QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
+ QuicTransportVersion version, int n);
+
+StreamType DetermineStreamType(QuicStreamId id, ParsedQuicVersion version,
+ Perspective perspective, bool is_incoming,
+ StreamType default_type);
+
+// Creates a MemSlice using a singleton trivial buffer allocator. Performs a
+// copy.
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data);
+
+// Used to compare ReceivedPacketInfo.
+MATCHER_P(ReceivedPacketInfoEquals, info, "") {
+ return info.ToString() == arg.ToString();
+}
+
+MATCHER_P(ReceivedPacketInfoConnectionIdEquals, destination_connection_id, "") {
+ return arg.destination_connection_id == destination_connection_id;
+}
+
+MATCHER_P2(InRange, min, max, "") { return arg >= min && arg <= max; }
+
+// A GMock matcher that prints expected and actual QuicErrorCode strings
+// upon failure. Example usage:
+// EXPECT_THAT(stream_->connection_error(), IsError(QUIC_INTERNAL_ERROR));
+MATCHER_P(IsError, expected,
+ absl::StrCat(negation ? "isn't equal to " : "is equal to ",
+ QuicErrorCodeToString(expected))) {
+ *result_listener << QuicErrorCodeToString(static_cast<QuicErrorCode>(arg));
+ return arg == expected;
+}
+
+// Shorthand for IsError(QUIC_NO_ERROR).
+// Example usage: EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
+MATCHER(IsQuicNoError,
+ absl::StrCat(negation ? "isn't equal to " : "is equal to ",
+ QuicErrorCodeToString(QUIC_NO_ERROR))) {
+ *result_listener << QuicErrorCodeToString(arg);
+ return arg == QUIC_NO_ERROR;
+}
+
+// A GMock matcher that prints expected and actual QuicRstStreamErrorCode
+// strings upon failure. Example usage:
+// EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
+MATCHER_P(IsStreamError, expected,
+ absl::StrCat(negation ? "isn't equal to " : "is equal to ",
+ QuicRstStreamErrorCodeToString(expected))) {
+ *result_listener << QuicRstStreamErrorCodeToString(arg);
+ return arg == expected;
+}
+
+// Shorthand for IsStreamError(QUIC_STREAM_NO_ERROR). Example usage:
+// EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+MATCHER(IsQuicStreamNoError,
+ absl::StrCat(negation ? "isn't equal to " : "is equal to ",
+ QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) {
+ *result_listener << QuicRstStreamErrorCodeToString(arg);
+ return arg == QUIC_STREAM_NO_ERROR;
+}
+
+// TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
+class TaggingEncrypter : public QuicEncrypter {
+ public:
+ explicit TaggingEncrypter(uint8_t tag) : tag_(tag) {}
+ TaggingEncrypter(const TaggingEncrypter&) = delete;
+ TaggingEncrypter& operator=(const TaggingEncrypter&) = delete;
+
+ ~TaggingEncrypter() override {}
+
+ // QuicEncrypter interface.
+ bool SetKey(absl::string_view /*key*/) override { return true; }
+
+ bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
+ return true;
+ }
+
+ bool SetIV(absl::string_view /*iv*/) override { return true; }
+
+ bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
+ return true;
+ }
+
+ bool EncryptPacket(uint64_t packet_number, absl::string_view associated_data,
+ absl::string_view plaintext, char* output,
+ size_t* output_length, size_t max_output_length) override;
+
+ std::string GenerateHeaderProtectionMask(
+ absl::string_view /*sample*/) override {
+ return std::string(5, 0);
+ }
+
+ size_t GetKeySize() const override { return 0; }
+ size_t GetNoncePrefixSize() const override { return 0; }
+ size_t GetIVSize() const override { return 0; }
+
+ size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
+ return ciphertext_size - kTagSize;
+ }
+
+ size_t GetCiphertextSize(size_t plaintext_size) const override {
+ return plaintext_size + kTagSize;
+ }
+
+ QuicPacketCount GetConfidentialityLimit() const override {
+ return std::numeric_limits<QuicPacketCount>::max();
+ }
+
+ absl::string_view GetKey() const override { return absl::string_view(); }
+
+ absl::string_view GetNoncePrefix() const override {
+ return absl::string_view();
+ }
+
+ private:
+ enum {
+ kTagSize = 12,
+ };
+
+ const uint8_t tag_;
+};
+
+// TaggingDecrypter ensures that the final kTagSize bytes of the message all
+// have the same value and then removes them.
+class TaggingDecrypter : public QuicDecrypter {
+ public:
+ ~TaggingDecrypter() override {}
+
+ // QuicDecrypter interface
+ bool SetKey(absl::string_view /*key*/) override { return true; }
+
+ bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
+ return true;
+ }
+
+ bool SetIV(absl::string_view /*iv*/) override { return true; }
+
+ bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
+ return true;
+ }
+
+ bool SetPreliminaryKey(absl::string_view /*key*/) override {
+ QUIC_BUG(quic_bug_10230_1) << "should not be called";
+ return false;
+ }
+
+ bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
+ return true;
+ }
+
+ bool DecryptPacket(uint64_t packet_number, absl::string_view associated_data,
+ absl::string_view ciphertext, char* output,
+ size_t* output_length, size_t max_output_length) override;
+
+ std::string GenerateHeaderProtectionMask(
+ QuicDataReader* /*sample_reader*/) override {
+ return std::string(5, 0);
+ }
+
+ size_t GetKeySize() const override { return 0; }
+ size_t GetNoncePrefixSize() const override { return 0; }
+ size_t GetIVSize() const override { return 0; }
+ absl::string_view GetKey() const override { return absl::string_view(); }
+ absl::string_view GetNoncePrefix() const override {
+ return absl::string_view();
+ }
+ // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
+ uint32_t cipher_id() const override { return 0xFFFFFFF0; }
+ QuicPacketCount GetIntegrityLimit() const override {
+ return std::numeric_limits<QuicPacketCount>::max();
+ }
+
+ protected:
+ virtual uint8_t GetTag(absl::string_view ciphertext) {
+ return ciphertext.data()[ciphertext.size() - 1];
+ }
+
+ private:
+ enum {
+ kTagSize = 12,
+ };
+
+ bool CheckTag(absl::string_view ciphertext, uint8_t tag);
+};
+
+// StringTaggingDecrypter ensures that the final kTagSize bytes of the message
+// match the expected value.
+class StrictTaggingDecrypter : public TaggingDecrypter {
+ public:
+ explicit StrictTaggingDecrypter(uint8_t tag) : tag_(tag) {}
+ ~StrictTaggingDecrypter() override {}
+
+ // TaggingQuicDecrypter
+ uint8_t GetTag(absl::string_view /*ciphertext*/) override { return tag_; }
+
+ // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
+ uint32_t cipher_id() const override { return 0xFFFFFFF1; }
+
+ private:
+ const uint8_t tag_;
+};
+
+class TestPacketWriter : public QuicPacketWriter {
+ struct PacketBuffer {
+ ABSL_CACHELINE_ALIGNED char buffer[1500];
+ bool in_use = false;
+ };
+
+ public:
+ TestPacketWriter(ParsedQuicVersion version, MockClock* clock,
+ Perspective perspective);
+
+ TestPacketWriter(const TestPacketWriter&) = delete;
+ TestPacketWriter& operator=(const TestPacketWriter&) = delete;
+
+ ~TestPacketWriter() override;
+
+ // QuicPacketWriter interface
+ WriteResult WritePacket(const char* buffer, size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+
+ bool ShouldWriteFail() { return write_should_fail_; }
+
+ bool IsWriteBlocked() const override { return write_blocked_; }
+
+ absl::optional<int> MessageTooBigErrorCode() const override { return 0x1234; }
+
+ void SetWriteBlocked() { write_blocked_ = true; }
+
+ void SetWritable() override { write_blocked_ = false; }
+
+ void SetShouldWriteFail() { write_should_fail_ = true; }
+
+ void SetWriteError(int error_code) { write_error_code_ = error_code; }
+
+ QuicByteCount GetMaxPacketSize(
+ const QuicSocketAddress& /*peer_address*/) const override {
+ return max_packet_size_;
+ }
+
+ bool SupportsReleaseTime() const override { return supports_release_time_; }
+
+ bool IsBatchMode() const override { return is_batch_mode_; }
+
+ QuicPacketBuffer GetNextWriteLocation(
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/) override;
+
+ WriteResult Flush() override;
+
+ void BlockOnNextFlush() { block_on_next_flush_ = true; }
+
+ void BlockOnNextWrite() { block_on_next_write_ = true; }
+
+ void SimulateNextPacketTooLarge() { next_packet_too_large_ = true; }
+
+ void AlwaysGetPacketTooLarge() { always_get_packet_too_large_ = true; }
+
+ // Sets the amount of time that the writer should before the actual write.
+ void SetWritePauseTimeDelta(QuicTime::Delta delta) {
+ write_pause_time_delta_ = delta;
+ }
+
+ void SetBatchMode(bool new_value) { is_batch_mode_ = new_value; }
+
+ const QuicPacketHeader& header() { return framer_.header(); }
+
+ size_t frame_count() const { return framer_.num_frames(); }
+
+ const std::vector<QuicAckFrame>& ack_frames() const {
+ return framer_.ack_frames();
+ }
+
+ const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
+ return framer_.stop_waiting_frames();
+ }
+
+ const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const {
+ return framer_.connection_close_frames();
+ }
+
+ const std::vector<QuicRstStreamFrame>& rst_stream_frames() const {
+ return framer_.rst_stream_frames();
+ }
+
+ const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
+ return framer_.stream_frames();
+ }
+
+ const std::vector<std::unique_ptr<QuicCryptoFrame>>& crypto_frames() const {
+ return framer_.crypto_frames();
+ }
+
+ const std::vector<QuicPingFrame>& ping_frames() const {
+ return framer_.ping_frames();
+ }
+
+ const std::vector<QuicMessageFrame>& message_frames() const {
+ return framer_.message_frames();
+ }
+
+ const std::vector<QuicWindowUpdateFrame>& window_update_frames() const {
+ return framer_.window_update_frames();
+ }
+
+ const std::vector<QuicPaddingFrame>& padding_frames() const {
+ return framer_.padding_frames();
+ }
+
+ const std::vector<QuicPathChallengeFrame>& path_challenge_frames() const {
+ return framer_.path_challenge_frames();
+ }
+
+ const std::vector<QuicPathResponseFrame>& path_response_frames() const {
+ return framer_.path_response_frames();
+ }
+
+ const QuicEncryptedPacket* coalesced_packet() const {
+ return framer_.coalesced_packet();
+ }
+
+ size_t last_packet_size() { return last_packet_size_; }
+
+ const QuicPacketHeader& last_packet_header() const {
+ return last_packet_header_;
+ }
+
+ const QuicVersionNegotiationPacket* version_negotiation_packet() {
+ return framer_.version_negotiation_packet();
+ }
+
+ void set_is_write_blocked_data_buffered(bool buffered) {
+ is_write_blocked_data_buffered_ = buffered;
+ }
+
+ void set_perspective(Perspective perspective) {
+ // We invert perspective here, because the framer needs to parse packets
+ // we send.
+ QuicFramerPeer::SetPerspective(framer_.framer(),
+ QuicUtils::InvertPerspective(perspective));
+ framer_.framer()->SetInitialObfuscators(TestConnectionId());
+ }
+
+ // final_bytes_of_last_packet_ returns the last four bytes of the previous
+ // packet as a little-endian, uint32_t. This is intended to be used with a
+ // TaggingEncrypter so that tests can determine which encrypter was used for
+ // a given packet.
+ uint32_t final_bytes_of_last_packet() { return final_bytes_of_last_packet_; }
+
+ // Returns the final bytes of the second to last packet.
+ uint32_t final_bytes_of_previous_packet() {
+ return final_bytes_of_previous_packet_;
+ }
+
+ void use_tagging_decrypter() { use_tagging_decrypter_ = true; }
+
+ uint32_t packets_write_attempts() const { return packets_write_attempts_; }
+
+ uint32_t flush_attempts() const { return flush_attempts_; }
+
+ uint32_t connection_close_packets() const {
+ return connection_close_packets_;
+ }
+
+ void Reset() { framer_.Reset(); }
+
+ void SetSupportedVersions(const ParsedQuicVersionVector& versions) {
+ framer_.SetSupportedVersions(versions);
+ }
+
+ void set_max_packet_size(QuicByteCount max_packet_size) {
+ max_packet_size_ = max_packet_size;
+ }
+
+ void set_supports_release_time(bool supports_release_time) {
+ supports_release_time_ = supports_release_time;
+ }
+
+ SimpleQuicFramer* framer() { return &framer_; }
+
+ const QuicIpAddress& last_write_source_address() const {
+ return last_write_source_address_;
+ }
+
+ const QuicSocketAddress& last_write_peer_address() const {
+ return last_write_peer_address_;
+ }
+
+ private:
+ char* AllocPacketBuffer();
+
+ void FreePacketBuffer(const char* buffer);
+
+ ParsedQuicVersion version_;
+ SimpleQuicFramer framer_;
+ size_t last_packet_size_ = 0;
+ QuicPacketHeader last_packet_header_;
+ bool write_blocked_ = false;
+ bool write_should_fail_ = false;
+ bool block_on_next_flush_ = false;
+ bool block_on_next_write_ = false;
+ bool next_packet_too_large_ = false;
+ bool always_get_packet_too_large_ = false;
+ bool is_write_blocked_data_buffered_ = false;
+ bool is_batch_mode_ = false;
+ // Number of times Flush() was called.
+ uint32_t flush_attempts_ = 0;
+ // (Batch mode only) Number of bytes buffered in writer. It is used as the
+ // return value of a successful Flush().
+ uint32_t bytes_buffered_ = 0;
+ uint32_t final_bytes_of_last_packet_ = 0;
+ uint32_t final_bytes_of_previous_packet_ = 0;
+ bool use_tagging_decrypter_ = false;
+ uint32_t packets_write_attempts_ = 0;
+ uint32_t connection_close_packets_ = 0;
+ MockClock* clock_ = nullptr;
+ // If non-zero, the clock will pause during WritePacket for this amount of
+ // time.
+ QuicTime::Delta write_pause_time_delta_ = QuicTime::Delta::Zero();
+ QuicByteCount max_packet_size_ = kMaxOutgoingPacketSize;
+ bool supports_release_time_ = false;
+ // Used to verify writer-allocated packet buffers are properly released.
+ std::vector<PacketBuffer*> packet_buffer_pool_;
+ // Buffer address => Address of the owning PacketBuffer.
+ absl::flat_hash_map<char*, PacketBuffer*, absl::Hash<char*>>
+ packet_buffer_pool_index_;
+ // Indices in packet_buffer_pool_ that are not allocated.
+ std::list<PacketBuffer*> packet_buffer_free_list_;
+ // The soruce/peer address passed into WritePacket().
+ QuicIpAddress last_write_source_address_;
+ QuicSocketAddress last_write_peer_address_;
+ int write_error_code_{0};
+};
+
+// Parses a packet generated by
+// QuicFramer::WriteClientVersionNegotiationProbePacket.
+// |packet_bytes| must point to |packet_length| bytes in memory which represent
+// the packet. This method will fill in |destination_connection_id_bytes|
+// which must point to at least |*destination_connection_id_length_out| bytes in
+// memory. |*destination_connection_id_length_out| will contain the length of
+// the received destination connection ID, which on success will match the
+// contents of the destination connection ID passed in to
+// WriteClientVersionNegotiationProbePacket.
+bool ParseClientVersionNegotiationProbePacket(
+ const char* packet_bytes, size_t packet_length,
+ char* destination_connection_id_bytes,
+ uint8_t* destination_connection_id_length_out);
+
+// Writes an array of bytes that correspond to a QUIC version negotiation packet
+// that a QUIC server would send in response to a probe created by
+// QuicFramer::WriteClientVersionNegotiationProbePacket.
+// The bytes will be written to |packet_bytes|, which must point to
+// |*packet_length_out| bytes of memory. |*packet_length_out| will contain the
+// length of the created packet. |source_connection_id_bytes| will be sent as
+// the source connection ID, and must point to |source_connection_id_length|
+// bytes of memory.
+bool WriteServerVersionNegotiationProbeResponse(
+ char* packet_bytes, size_t* packet_length_out,
+ const char* source_connection_id_bytes,
+ uint8_t source_connection_id_length);
+
+// Implementation of Http3DatagramVisitor which saves all received datagrams.
+class SavingHttp3DatagramVisitor : public QuicSpdyStream::Http3DatagramVisitor {
+ public:
+ struct SavedHttp3Datagram {
+ QuicStreamId stream_id;
+ absl::optional<QuicDatagramContextId> context_id;
+ std::string payload;
+ bool operator==(const SavedHttp3Datagram& o) const {
+ return stream_id == o.stream_id && context_id == o.context_id &&
+ payload == o.payload;
+ }
+ };
+ const std::vector<SavedHttp3Datagram>& received_h3_datagrams() const {
+ return received_h3_datagrams_;
+ }
+
+ // Override from QuicSpdyStream::Http3DatagramVisitor.
+ void OnHttp3Datagram(QuicStreamId stream_id,
+ absl::optional<QuicDatagramContextId> context_id,
+ absl::string_view payload) override {
+ received_h3_datagrams_.push_back(
+ SavedHttp3Datagram{stream_id, context_id, std::string(payload)});
+ }
+
+ private:
+ std::vector<SavedHttp3Datagram> received_h3_datagrams_;
+};
+
+class MockHttp3DatagramRegistrationVisitor
+ : public QuicSpdyStream::Http3DatagramRegistrationVisitor {
+ public:
+ MOCK_METHOD(void, OnContextReceived,
+ (QuicStreamId stream_id,
+ absl::optional<QuicDatagramContextId> context_id,
+ DatagramFormatType format_type,
+ absl::string_view format_additional_data),
+ (override));
+
+ MOCK_METHOD(void, OnContextClosed,
+ (QuicStreamId stream_id,
+ absl::optional<QuicDatagramContextId> context_id,
+ ContextCloseCode close_code, absl::string_view close_details),
+ (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/quic_test_utils_test.cc b/quiche/quic/test_tools/quic_test_utils_test.cc
new file mode 100644
index 0000000..16ca977
--- /dev/null
+++ b/quiche/quic/test_tools/quic_test_utils_test.cc
@@ -0,0 +1,79 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class QuicTestUtilsTest : public QuicTest {};
+
+TEST_F(QuicTestUtilsTest, ConnectionId) {
+ EXPECT_NE(EmptyQuicConnectionId(), TestConnectionId());
+ EXPECT_NE(EmptyQuicConnectionId(), TestConnectionId(1));
+ EXPECT_EQ(TestConnectionId(), TestConnectionId());
+ EXPECT_EQ(TestConnectionId(33), TestConnectionId(33));
+ EXPECT_NE(TestConnectionId(0xdead), TestConnectionId(0xbeef));
+ EXPECT_EQ(0x1337u, TestConnectionIdToUInt64(TestConnectionId(0x1337)));
+ EXPECT_NE(0xdeadu, TestConnectionIdToUInt64(TestConnectionId(0xbeef)));
+}
+
+TEST_F(QuicTestUtilsTest, BasicApproxEq) {
+ EXPECT_APPROX_EQ(10, 10, 1e-6f);
+ EXPECT_APPROX_EQ(1000, 1001, 0.01f);
+ EXPECT_NONFATAL_FAILURE(EXPECT_APPROX_EQ(1000, 1100, 0.01f), "");
+
+ EXPECT_APPROX_EQ(64, 31, 0.55f);
+ EXPECT_NONFATAL_FAILURE(EXPECT_APPROX_EQ(31, 64, 0.55f), "");
+}
+
+TEST_F(QuicTestUtilsTest, QuicTimeDelta) {
+ EXPECT_APPROX_EQ(QuicTime::Delta::FromMicroseconds(1000),
+ QuicTime::Delta::FromMicroseconds(1003), 0.01f);
+ EXPECT_NONFATAL_FAILURE(
+ EXPECT_APPROX_EQ(QuicTime::Delta::FromMicroseconds(1000),
+ QuicTime::Delta::FromMicroseconds(1200), 0.01f),
+ "");
+}
+
+TEST_F(QuicTestUtilsTest, QuicBandwidth) {
+ EXPECT_APPROX_EQ(QuicBandwidth::FromBytesPerSecond(1000),
+ QuicBandwidth::FromBitsPerSecond(8005), 0.01f);
+ EXPECT_NONFATAL_FAILURE(
+ EXPECT_APPROX_EQ(QuicBandwidth::FromBytesPerSecond(1000),
+ QuicBandwidth::FromBitsPerSecond(9005), 0.01f),
+ "");
+}
+
+// Ensure that SimpleRandom does not change its output for a fixed seed.
+TEST_F(QuicTestUtilsTest, SimpleRandomStability) {
+ SimpleRandom rng;
+ rng.set_seed(UINT64_C(0x1234567800010001));
+ EXPECT_EQ(UINT64_C(12589383305231984671), rng.RandUint64());
+ EXPECT_EQ(UINT64_C(17775425089941798664), rng.RandUint64());
+}
+
+// Ensure that the output of SimpleRandom does not depend on the size of the
+// read calls.
+TEST_F(QuicTestUtilsTest, SimpleRandomChunks) {
+ SimpleRandom rng;
+ std::string reference(16 * 1024, '\0');
+ rng.RandBytes(&reference[0], reference.size());
+
+ for (size_t chunk_size : {3, 4, 7, 4096}) {
+ rng.set_seed(0);
+ size_t chunks = reference.size() / chunk_size;
+ std::string buffer(chunks * chunk_size, '\0');
+ for (size_t i = 0; i < chunks; i++) {
+ rng.RandBytes(&buffer[i * chunk_size], chunk_size);
+ }
+ EXPECT_EQ(reference.substr(0, buffer.size()), buffer)
+ << "Failed for chunk_size = " << chunk_size;
+ }
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc
new file mode 100644
index 0000000..5199282
--- /dev/null
+++ b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc
@@ -0,0 +1,46 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_time_wait_list_manager_peer.h"
+
+namespace quic {
+namespace test {
+
+bool QuicTimeWaitListManagerPeer::ShouldSendResponse(
+ QuicTimeWaitListManager* manager,
+ int received_packet_count) {
+ return manager->ShouldSendResponse(received_packet_count);
+}
+
+QuicTime::Delta QuicTimeWaitListManagerPeer::time_wait_period(
+ QuicTimeWaitListManager* manager) {
+ return manager->time_wait_period_;
+}
+
+QuicAlarm* QuicTimeWaitListManagerPeer::expiration_alarm(
+ QuicTimeWaitListManager* manager) {
+ return manager->connection_id_clean_up_alarm_.get();
+}
+
+void QuicTimeWaitListManagerPeer::set_clock(QuicTimeWaitListManager* manager,
+ const QuicClock* clock) {
+ manager->clock_ = clock;
+}
+
+// static
+bool QuicTimeWaitListManagerPeer::SendOrQueuePacket(
+ QuicTimeWaitListManager* manager,
+ std::unique_ptr<QuicTimeWaitListManager::QueuedPacket> packet,
+ const QuicPerPacketContext* packet_context) {
+ return manager->SendOrQueuePacket(std::move(packet), packet_context);
+}
+
+// static
+size_t QuicTimeWaitListManagerPeer::PendingPacketsQueueSize(
+ QuicTimeWaitListManager* manager) {
+ return manager->pending_packets_queue_.size();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_time_wait_list_manager_peer.h b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.h
new file mode 100644
index 0000000..a7aed47
--- /dev/null
+++ b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TIME_WAIT_LIST_MANAGER_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TIME_WAIT_LIST_MANAGER_PEER_H_
+
+#include "quiche/quic/core/quic_time_wait_list_manager.h"
+
+namespace quic {
+namespace test {
+
+class QuicTimeWaitListManagerPeer {
+ public:
+ static bool ShouldSendResponse(QuicTimeWaitListManager* manager,
+ int received_packet_count);
+
+ static QuicTime::Delta time_wait_period(QuicTimeWaitListManager* manager);
+
+ static QuicAlarm* expiration_alarm(QuicTimeWaitListManager* manager);
+
+ static void set_clock(QuicTimeWaitListManager* manager,
+ const QuicClock* clock);
+
+ static bool SendOrQueuePacket(
+ QuicTimeWaitListManager* manager,
+ std::unique_ptr<QuicTimeWaitListManager::QueuedPacket> packet,
+ const QuicPerPacketContext* packet_context);
+
+ static size_t PendingPacketsQueueSize(QuicTimeWaitListManager* manager);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TIME_WAIT_LIST_MANAGER_PEER_H_
diff --git a/quiche/quic/test_tools/quic_transport_test_tools.h b/quiche/quic/test_tools/quic_transport_test_tools.h
new file mode 100644
index 0000000..08d87ef
--- /dev/null
+++ b/quiche/quic/test_tools/quic_transport_test_tools.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_TRANSPORT_TEST_TOOLS_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_TRANSPORT_TEST_TOOLS_H_
+
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/quic_transport/quic_transport_server_session.h"
+
+namespace quic {
+namespace test {
+
+class MockClientVisitor : public WebTransportVisitor {
+ public:
+ MOCK_METHOD(void, OnSessionReady, (const spdy::SpdyHeaderBlock&), (override));
+ MOCK_METHOD(void, OnSessionClosed,
+ (WebTransportSessionError, const std::string&), (override));
+ MOCK_METHOD(void, OnIncomingBidirectionalStreamAvailable, (), (override));
+ MOCK_METHOD(void, OnIncomingUnidirectionalStreamAvailable, (), (override));
+ MOCK_METHOD(void, OnDatagramReceived, (absl::string_view), (override));
+ MOCK_METHOD(void, OnCanCreateNewOutgoingBidirectionalStream, (), (override));
+ MOCK_METHOD(void, OnCanCreateNewOutgoingUnidirectionalStream, (), (override));
+};
+
+class MockServerVisitor : public QuicTransportServerSession::ServerVisitor {
+ public:
+ MOCK_METHOD(bool, CheckOrigin, (url::Origin), (override));
+ MOCK_METHOD(bool, ProcessPath, (const GURL&), (override));
+};
+
+class MockStreamVisitor : public WebTransportStreamVisitor {
+ public:
+ MOCK_METHOD(void, OnCanRead, (), (override));
+ MOCK_METHOD(void, OnCanWrite, (), (override));
+
+ MOCK_METHOD(void, OnResetStreamReceived, (WebTransportStreamError error),
+ (override));
+ MOCK_METHOD(void, OnStopSendingReceived, (WebTransportStreamError error),
+ (override));
+ MOCK_METHOD(void, OnWriteSideInDataRecvdState, (), (override));
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_TRANSPORT_TEST_TOOLS_H_
diff --git a/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc b/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc
new file mode 100644
index 0000000..d253cc2
--- /dev/null
+++ b/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/quic_unacked_packet_map_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+const QuicStreamFrame& QuicUnackedPacketMapPeer::GetAggregatedStreamFrame(
+ const QuicUnackedPacketMap& unacked_packets) {
+ return unacked_packets.aggregated_stream_frame_;
+}
+
+// static
+void QuicUnackedPacketMapPeer::SetPerspective(
+ QuicUnackedPacketMap* unacked_packets,
+ Perspective perspective) {
+ *const_cast<Perspective*>(&unacked_packets->perspective_) = perspective;
+}
+
+// static
+size_t QuicUnackedPacketMapPeer::GetCapacity(
+ const QuicUnackedPacketMap& unacked_packets) {
+ return unacked_packets.unacked_packets_.capacity();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/quic_unacked_packet_map_peer.h b/quiche/quic/test_tools/quic_unacked_packet_map_peer.h
new file mode 100644
index 0000000..5525506
--- /dev/null
+++ b/quiche/quic/test_tools/quic_unacked_packet_map_peer.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_UNACKED_PACKET_MAP_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_QUIC_UNACKED_PACKET_MAP_PEER_H_
+
+#include "quiche/quic/core/quic_unacked_packet_map.h"
+
+namespace quic {
+namespace test {
+
+class QuicUnackedPacketMapPeer {
+ public:
+ static const QuicStreamFrame& GetAggregatedStreamFrame(
+ const QuicUnackedPacketMap& unacked_packets);
+
+ static void SetPerspective(QuicUnackedPacketMap* unacked_packets,
+ Perspective perspective);
+
+ static size_t GetCapacity(const QuicUnackedPacketMap& unacked_packets);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_QUIC_UNACKED_PACKET_MAP_PEER_H_
diff --git a/quiche/quic/test_tools/rtt_stats_peer.cc b/quiche/quic/test_tools/rtt_stats_peer.cc
new file mode 100644
index 0000000..8bf1f99
--- /dev/null
+++ b/quiche/quic/test_tools/rtt_stats_peer.cc
@@ -0,0 +1,21 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/rtt_stats_peer.h"
+
+namespace quic {
+namespace test {
+
+// static
+void RttStatsPeer::SetSmoothedRtt(RttStats* rtt_stats, QuicTime::Delta rtt_ms) {
+ rtt_stats->smoothed_rtt_ = rtt_ms;
+}
+
+// static
+void RttStatsPeer::SetMinRtt(RttStats* rtt_stats, QuicTime::Delta rtt_ms) {
+ rtt_stats->min_rtt_ = rtt_ms;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/rtt_stats_peer.h b/quiche/quic/test_tools/rtt_stats_peer.h
new file mode 100644
index 0000000..5e7f473
--- /dev/null
+++ b/quiche/quic/test_tools/rtt_stats_peer.h
@@ -0,0 +1,26 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_RTT_STATS_PEER_H_
+#define QUICHE_QUIC_TEST_TOOLS_RTT_STATS_PEER_H_
+
+#include "quiche/quic/core/congestion_control/rtt_stats.h"
+#include "quiche/quic/core/quic_time.h"
+
+namespace quic {
+namespace test {
+
+class RttStatsPeer {
+ public:
+ RttStatsPeer() = delete;
+
+ static void SetSmoothedRtt(RttStats* rtt_stats, QuicTime::Delta rtt_ms);
+
+ static void SetMinRtt(RttStats* rtt_stats, QuicTime::Delta rtt_ms);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_RTT_STATS_PEER_H_
diff --git a/quiche/quic/test_tools/send_algorithm_test_result.proto b/quiche/quic/test_tools/send_algorithm_test_result.proto
new file mode 100644
index 0000000..a836c47
--- /dev/null
+++ b/quiche/quic/test_tools/send_algorithm_test_result.proto
@@ -0,0 +1,15 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+
+package quic;
+
+message SendAlgorithmTestResult {
+ optional string test_name = 1;
+ optional uint64 random_seed = 2;
+ optional int64 simulated_duration_micros = 3;
+}
diff --git a/quiche/quic/test_tools/send_algorithm_test_utils.cc b/quiche/quic/test_tools/send_algorithm_test_utils.cc
new file mode 100644
index 0000000..2ca1791
--- /dev/null
+++ b/quiche/quic/test_tools/send_algorithm_test_utils.cc
@@ -0,0 +1,61 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/send_algorithm_test_utils.h"
+
+#include "absl/strings/str_cat.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/platform/api/quic_test_output.h"
+
+namespace quic {
+namespace test {
+
+bool LoadSendAlgorithmTestResult(SendAlgorithmTestResult* result) {
+ std::string test_result_file_content;
+ if (!QuicLoadTestOutput(GetSendAlgorithmTestResultFilename(),
+ &test_result_file_content)) {
+ return false;
+ }
+ return result->ParseFromString(test_result_file_content);
+}
+
+void RecordSendAlgorithmTestResult(uint64_t random_seed,
+ int64_t simulated_duration_micros) {
+ SendAlgorithmTestResult result;
+ result.set_test_name(GetFullSendAlgorithmTestName());
+ result.set_random_seed(random_seed);
+ result.set_simulated_duration_micros(simulated_duration_micros);
+
+ QuicSaveTestOutput(GetSendAlgorithmTestResultFilename(),
+ result.SerializeAsString());
+}
+
+void CompareSendAlgorithmTestResult(int64_t actual_simulated_duration_micros) {
+ SendAlgorithmTestResult expected;
+ ASSERT_TRUE(LoadSendAlgorithmTestResult(&expected));
+ QUIC_LOG(INFO) << "Loaded expected test result: "
+ << expected.ShortDebugString();
+
+ EXPECT_GE(expected.simulated_duration_micros(),
+ actual_simulated_duration_micros);
+}
+
+std::string GetFullSendAlgorithmTestName() {
+ const auto* test_info =
+ ::testing::UnitTest::GetInstance()->current_test_info();
+ const std::string type_param =
+ test_info->type_param() ? test_info->type_param() : "";
+ const std::string value_param =
+ test_info->value_param() ? test_info->value_param() : "";
+ return absl::StrCat(test_info->test_suite_name(), ".", test_info->name(), "_",
+ type_param, "_", value_param);
+}
+
+std::string GetSendAlgorithmTestResultFilename() {
+ return GetFullSendAlgorithmTestName() + ".test_result";
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/send_algorithm_test_utils.h b/quiche/quic/test_tools/send_algorithm_test_utils.h
new file mode 100644
index 0000000..9516b9a
--- /dev/null
+++ b/quiche/quic/test_tools/send_algorithm_test_utils.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SEND_ALGORITHM_TEST_UTILS_H_
+#define QUICHE_QUIC_TEST_TOOLS_SEND_ALGORITHM_TEST_UTILS_H_
+
+#include "quiche/quic/test_tools/send_algorithm_test_result.pb.h"
+
+namespace quic {
+namespace test {
+
+bool LoadSendAlgorithmTestResult(SendAlgorithmTestResult* result);
+
+void RecordSendAlgorithmTestResult(uint64_t random_seed,
+ int64_t simulated_duration_micros);
+
+// Load the expected test result with LoadSendAlgorithmTestResult(), and compare
+// it with the actual results provided in the arguments.
+void CompareSendAlgorithmTestResult(int64_t actual_simulated_duration_micros);
+
+std::string GetFullSendAlgorithmTestName();
+
+std::string GetSendAlgorithmTestResultFilename();
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SEND_ALGORITHM_TEST_UTILS_H_
diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
new file mode 100644
index 0000000..12d2fc2
--- /dev/null
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -0,0 +1,141 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/server_thread.h"
+
+#include "quiche/quic/core/quic_dispatcher.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/test_tools/crypto_test_utils.h"
+#include "quiche/quic/test_tools/quic_dispatcher_peer.h"
+#include "quiche/quic/test_tools/quic_server_peer.h"
+
+namespace quic {
+namespace test {
+
+ServerThread::ServerThread(QuicServer* server, const QuicSocketAddress& address)
+ : QuicThread("server_thread"),
+ server_(server),
+ clock_(server->epoll_server()),
+ address_(address),
+ port_(0),
+ initialized_(false) {}
+
+ServerThread::~ServerThread() = default;
+
+void ServerThread::Initialize() {
+ if (initialized_) {
+ return;
+ }
+
+ server_->CreateUDPSocketAndListen(address_);
+
+ QuicWriterMutexLock lock(&port_lock_);
+ port_ = server_->port();
+
+ initialized_ = true;
+}
+
+void ServerThread::Run() {
+ if (!initialized_) {
+ Initialize();
+ }
+
+ while (!quit_.HasBeenNotified()) {
+ if (pause_.HasBeenNotified() && !resume_.HasBeenNotified()) {
+ paused_.Notify();
+ resume_.WaitForNotification();
+ }
+ server_->WaitForEvents();
+ ExecuteScheduledActions();
+ MaybeNotifyOfHandshakeConfirmation();
+ }
+
+ server_->Shutdown();
+}
+
+int ServerThread::GetPort() {
+ QuicReaderMutexLock lock(&port_lock_);
+ int rc = port_;
+ return rc;
+}
+
+void ServerThread::Schedule(std::function<void()> action) {
+ QUICHE_DCHECK(!quit_.HasBeenNotified());
+ QuicWriterMutexLock lock(&scheduled_actions_lock_);
+ scheduled_actions_.push_back(std::move(action));
+}
+
+void ServerThread::WaitForCryptoHandshakeConfirmed() {
+ confirmed_.WaitForNotification();
+}
+
+bool ServerThread::WaitUntil(std::function<bool()> termination_predicate,
+ QuicTime::Delta timeout) {
+ const QuicTime deadline = clock_.Now() + timeout;
+ while (clock_.Now() < deadline) {
+ QuicNotification done_checking;
+ bool should_terminate = false;
+ Schedule([&] {
+ should_terminate = termination_predicate();
+ done_checking.Notify();
+ });
+ done_checking.WaitForNotification();
+ if (should_terminate) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void ServerThread::Pause() {
+ QUICHE_DCHECK(!pause_.HasBeenNotified());
+ pause_.Notify();
+ paused_.WaitForNotification();
+}
+
+void ServerThread::Resume() {
+ QUICHE_DCHECK(!resume_.HasBeenNotified());
+ QUICHE_DCHECK(pause_.HasBeenNotified());
+ resume_.Notify();
+}
+
+void ServerThread::Quit() {
+ if (pause_.HasBeenNotified() && !resume_.HasBeenNotified()) {
+ resume_.Notify();
+ }
+ if (!quit_.HasBeenNotified()) {
+ quit_.Notify();
+ }
+}
+
+void ServerThread::MaybeNotifyOfHandshakeConfirmation() {
+ if (confirmed_.HasBeenNotified()) {
+ // Only notify once.
+ return;
+ }
+ QuicDispatcher* dispatcher = QuicServerPeer::GetDispatcher(server());
+ if (dispatcher->NumSessions() == 0) {
+ // Wait for a session to be created.
+ return;
+ }
+ QuicSession* session = QuicDispatcherPeer::GetFirstSessionIfAny(dispatcher);
+ if (session->OneRttKeysAvailable()) {
+ confirmed_.Notify();
+ }
+}
+
+void ServerThread::ExecuteScheduledActions() {
+ quiche::QuicheCircularDeque<std::function<void()>> actions;
+ {
+ QuicWriterMutexLock lock(&scheduled_actions_lock_);
+ actions.swap(scheduled_actions_);
+ }
+ while (!actions.empty()) {
+ actions.front()();
+ actions.pop_front();
+ }
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/server_thread.h b/quiche/quic/test_tools/server_thread.h
new file mode 100644
index 0000000..7f5d45a
--- /dev/null
+++ b/quiche/quic/test_tools/server_thread.h
@@ -0,0 +1,97 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SERVER_THREAD_H_
+#define QUICHE_QUIC_TEST_TOOLS_SERVER_THREAD_H_
+
+#include <memory>
+
+#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_epoll_clock.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/platform/api/quic_mutex.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/quic/platform/api/quic_thread.h"
+#include "quiche/quic/tools/quic_server.h"
+
+namespace quic {
+namespace test {
+
+// Simple wrapper class to run QuicServer in a dedicated thread.
+class ServerThread : public QuicThread {
+ public:
+ ServerThread(QuicServer* server, const QuicSocketAddress& address);
+ ServerThread(const ServerThread&) = delete;
+ ServerThread& operator=(const ServerThread&) = delete;
+
+ ~ServerThread() override;
+
+ // Prepares the server, but does not start accepting connections. Useful for
+ // injecting mocks.
+ void Initialize();
+
+ // Runs the event loop. Will initialize if necessary.
+ void Run() override;
+
+ // Schedules the given action for execution in the event loop.
+ void Schedule(std::function<void()> action);
+
+ // Waits for the handshake to be confirmed for the first session created.
+ void WaitForCryptoHandshakeConfirmed();
+
+ // Wait until |termination_predicate| returns true in server thread, or
+ // reached |timeout|. Must be called from an external thread.
+ // Return whether the function returned after |termination_predicate| become
+ // true.
+ bool WaitUntil(std::function<bool()> termination_predicate,
+ QuicTime::Delta timeout);
+
+ // Pauses execution of the server until Resume() is called. May only be
+ // called once.
+ void Pause();
+
+ // Resumes execution of the server after Pause() has been called. May only
+ // be called once.
+ void Resume();
+
+ // Stops the server from executing and shuts it down, destroying all
+ // server objects.
+ void Quit();
+
+ // Returns the underlying server. Care must be taken to avoid data races
+ // when accessing the server. It is always safe to access the server
+ // after calling Pause() and before calling Resume().
+ QuicServer* server() { return server_.get(); }
+
+ // Returns the port that the server is listening on.
+ int GetPort();
+
+ private:
+ void MaybeNotifyOfHandshakeConfirmation();
+ void ExecuteScheduledActions();
+
+ QuicNotification
+ confirmed_; // Notified when the first handshake is confirmed.
+ QuicNotification pause_; // Notified when the server should pause.
+ QuicNotification paused_; // Notitied when the server has paused
+ QuicNotification resume_; // Notified when the server should resume.
+ QuicNotification quit_; // Notified when the server should quit.
+
+ std::unique_ptr<QuicServer> server_;
+ QuicEpollClock clock_;
+ QuicSocketAddress address_;
+ mutable QuicMutex port_lock_;
+ int port_ QUIC_GUARDED_BY(port_lock_);
+
+ bool initialized_;
+
+ QuicMutex scheduled_actions_lock_;
+ quiche::QuicheCircularDeque<std::function<void()>> scheduled_actions_
+ QUIC_GUARDED_BY(scheduled_actions_lock_);
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SERVER_THREAD_H_
diff --git a/quiche/quic/test_tools/simple_data_producer.cc b/quiche/quic/test_tools/simple_data_producer.cc
new file mode 100644
index 0000000..cf899c5
--- /dev/null
+++ b/quiche/quic/test_tools/simple_data_producer.cc
@@ -0,0 +1,69 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simple_data_producer.h"
+
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+
+namespace quic {
+
+namespace test {
+
+SimpleDataProducer::SimpleDataProducer() {}
+
+SimpleDataProducer::~SimpleDataProducer() {}
+
+void SimpleDataProducer::SaveStreamData(QuicStreamId id,
+ absl::string_view data) {
+ if (data.empty()) {
+ return;
+ }
+ if (!send_buffer_map_.contains(id)) {
+ send_buffer_map_[id] = std::make_unique<QuicStreamSendBuffer>(&allocator_);
+ }
+ send_buffer_map_[id]->SaveStreamData(data);
+}
+
+void SimpleDataProducer::SaveCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ absl::string_view data) {
+ auto key = std::make_pair(level, offset);
+ crypto_buffer_map_[key] = std::string(data);
+}
+
+WriteStreamDataResult SimpleDataProducer::WriteStreamData(
+ QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) {
+ auto iter = send_buffer_map_.find(id);
+ if (iter == send_buffer_map_.end()) {
+ return STREAM_MISSING;
+ }
+ if (iter->second->WriteStreamData(offset, data_length, writer)) {
+ return WRITE_SUCCESS;
+ }
+ return WRITE_FAILED;
+}
+
+bool SimpleDataProducer::WriteCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) {
+ auto it = crypto_buffer_map_.find(std::make_pair(level, offset));
+ if (it == crypto_buffer_map_.end() || it->second.length() < data_length) {
+ return false;
+ }
+ return writer->WriteStringPiece(
+ absl::string_view(it->second.data(), data_length));
+}
+
+} // namespace test
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/simple_data_producer.h b/quiche/quic/test_tools/simple_data_producer.h
new file mode 100644
index 0000000..938c87e
--- /dev/null
+++ b/quiche/quic/test_tools/simple_data_producer.h
@@ -0,0 +1,76 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_stream_frame_data_producer.h"
+#include "quiche/quic/core/quic_stream_send_buffer.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/common/simple_buffer_allocator.h"
+
+namespace quic {
+
+namespace test {
+
+// A simple data producer which copies stream data into a map from stream
+// id to send buffer.
+class SimpleDataProducer : public QuicStreamFrameDataProducer {
+ public:
+ SimpleDataProducer();
+ ~SimpleDataProducer() override;
+
+ // Saves `data` to be provided when WriteStreamData() is called. Multiple
+ // calls to SaveStreamData() for the same stream ID append to the buffer for
+ // that stream.
+ void SaveStreamData(QuicStreamId id, absl::string_view data);
+
+ void SaveCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ absl::string_view data);
+
+ // QuicStreamFrameDataProducer
+ WriteStreamDataResult WriteStreamData(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ bool WriteCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+
+ private:
+ using SendBufferMap =
+ absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStreamSendBuffer>>;
+
+ using CryptoBufferMap =
+ absl::flat_hash_map<std::pair<EncryptionLevel, QuicStreamOffset>,
+ std::string>;
+
+ quiche::SimpleBufferAllocator allocator_;
+
+ SendBufferMap send_buffer_map_;
+
+ // |crypto_buffer_map_| stores data provided by SaveCryptoData to later write
+ // in WriteCryptoData. The level and data passed into SaveCryptoData are used
+ // as the key to identify the data when WriteCryptoData is called.
+ // WriteCryptoData will only succeed if there is data in the map for the
+ // provided level and offset, and the data in the map matches the data_length
+ // passed into WriteCryptoData.
+ //
+ // Unlike SaveStreamData/WriteStreamData which uses a map of
+ // QuicStreamSendBuffers (for each stream ID), this map provides data for
+ // specific offsets. Using a QuicStreamSendBuffer requires that all data
+ // before an offset exist, whereas this allows providing data that exists at
+ // arbitrary offsets for testing.
+ CryptoBufferMap crypto_buffer_map_;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
diff --git a/quiche/quic/test_tools/simple_quic_framer.cc b/quiche/quic/test_tools/simple_quic_framer.cc
new file mode 100644
index 0000000..9f1910f
--- /dev/null
+++ b/quiche/quic/test_tools/simple_quic_framer.cc
@@ -0,0 +1,444 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simple_quic_framer.h"
+
+#include <memory>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/quic_decrypter.h"
+#include "quiche/quic/core/crypto/quic_encrypter.h"
+#include "quiche/quic/core/quic_types.h"
+
+namespace quic {
+namespace test {
+
+class SimpleFramerVisitor : public QuicFramerVisitorInterface {
+ public:
+ SimpleFramerVisitor() : error_(QUIC_NO_ERROR) {}
+ SimpleFramerVisitor(const SimpleFramerVisitor&) = delete;
+ SimpleFramerVisitor& operator=(const SimpleFramerVisitor&) = delete;
+
+ ~SimpleFramerVisitor() override {}
+
+ void OnError(QuicFramer* framer) override { error_ = framer->error(); }
+
+ bool OnProtocolVersionMismatch(ParsedQuicVersion /*version*/) override {
+ return false;
+ }
+
+ void OnPacket() override {}
+ void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
+ public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
+ }
+ void OnVersionNegotiationPacket(
+ const QuicVersionNegotiationPacket& packet) override {
+ version_negotiation_packet_ =
+ std::make_unique<QuicVersionNegotiationPacket>((packet));
+ }
+
+ void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
+ QuicConnectionId /*new_connection_id*/,
+ absl::string_view /*retry_token*/,
+ absl::string_view /*retry_integrity_tag*/,
+ absl::string_view /*retry_without_tag*/) override {}
+
+ bool OnUnauthenticatedPublicHeader(
+ const QuicPacketHeader& /*header*/) override {
+ return true;
+ }
+ bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
+ return true;
+ }
+ void OnDecryptedPacket(size_t /*length*/, EncryptionLevel level) override {
+ last_decrypted_level_ = level;
+ }
+ bool OnPacketHeader(const QuicPacketHeader& header) override {
+ has_header_ = true;
+ header_ = header;
+ return true;
+ }
+
+ void OnCoalescedPacket(const QuicEncryptedPacket& packet) override {
+ coalesced_packet_ = packet.Clone();
+ }
+
+ void OnUndecryptablePacket(const QuicEncryptedPacket& /*packet*/,
+ EncryptionLevel /*decryption_level*/,
+ bool /*has_decryption_key*/) override {}
+
+ bool OnStreamFrame(const QuicStreamFrame& frame) override {
+ // Save a copy of the data so it is valid after the packet is processed.
+ std::string* string_data =
+ new std::string(frame.data_buffer, frame.data_length);
+ stream_data_.push_back(absl::WrapUnique(string_data));
+ // TODO(ianswett): A pointer isn't necessary with emplace_back.
+ stream_frames_.push_back(std::make_unique<QuicStreamFrame>(
+ frame.stream_id, frame.fin, frame.offset,
+ absl::string_view(*string_data)));
+ return true;
+ }
+
+ bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
+ // Save a copy of the data so it is valid after the packet is processed.
+ std::string* string_data =
+ new std::string(frame.data_buffer, frame.data_length);
+ crypto_data_.push_back(absl::WrapUnique(string_data));
+ crypto_frames_.push_back(std::make_unique<QuicCryptoFrame>(
+ frame.level, frame.offset, absl::string_view(*string_data)));
+ return true;
+ }
+
+ bool OnAckFrameStart(QuicPacketNumber largest_acked,
+ QuicTime::Delta ack_delay_time) override {
+ QuicAckFrame ack_frame;
+ ack_frame.largest_acked = largest_acked;
+ ack_frame.ack_delay_time = ack_delay_time;
+ ack_frames_.push_back(ack_frame);
+ return true;
+ }
+
+ bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override {
+ QUICHE_DCHECK(!ack_frames_.empty());
+ ack_frames_[ack_frames_.size() - 1].packets.AddRange(start, end);
+ return true;
+ }
+
+ bool OnAckTimestamp(QuicPacketNumber /*packet_number*/,
+ QuicTime /*timestamp*/) override {
+ return true;
+ }
+
+ bool OnAckFrameEnd(QuicPacketNumber /*start*/) override { return true; }
+
+ bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
+ stop_waiting_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnPaddingFrame(const QuicPaddingFrame& frame) override {
+ padding_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnPingFrame(const QuicPingFrame& frame) override {
+ ping_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
+ rst_stream_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
+ connection_close_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override {
+ new_connection_id_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnRetireConnectionIdFrame(
+ const QuicRetireConnectionIdFrame& frame) override {
+ retire_connection_id_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override {
+ new_token_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override {
+ stop_sending_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override {
+ path_challenge_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override {
+ path_response_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
+ goaway_frames_.push_back(frame);
+ return true;
+ }
+ bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override {
+ max_streams_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override {
+ streams_blocked_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override {
+ window_update_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
+ blocked_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnMessageFrame(const QuicMessageFrame& frame) override {
+ message_frames_.emplace_back(frame.data, frame.message_length);
+ return true;
+ }
+
+ bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override {
+ handshake_done_frames_.push_back(frame);
+ return true;
+ }
+
+ bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override {
+ ack_frequency_frames_.push_back(frame);
+ return true;
+ }
+
+ void OnPacketComplete() override {}
+
+ bool IsValidStatelessResetToken(
+ const StatelessResetToken& /*token*/) const override {
+ return false;
+ }
+
+ void OnAuthenticatedIetfStatelessResetPacket(
+ const QuicIetfStatelessResetPacket& packet) override {
+ stateless_reset_packet_ =
+ std::make_unique<QuicIetfStatelessResetPacket>(packet);
+ }
+
+ void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
+ void OnDecryptedFirstPacketInKeyPhase() override {}
+ std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
+ override {
+ return nullptr;
+ }
+ std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
+ return nullptr;
+ }
+
+ const QuicPacketHeader& header() const { return header_; }
+ const std::vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
+ const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const {
+ return connection_close_frames_;
+ }
+
+ const std::vector<QuicGoAwayFrame>& goaway_frames() const {
+ return goaway_frames_;
+ }
+ const std::vector<QuicMaxStreamsFrame>& max_streams_frames() const {
+ return max_streams_frames_;
+ }
+ const std::vector<QuicStreamsBlockedFrame>& streams_blocked_frames() const {
+ return streams_blocked_frames_;
+ }
+ const std::vector<QuicRstStreamFrame>& rst_stream_frames() const {
+ return rst_stream_frames_;
+ }
+ const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
+ return stream_frames_;
+ }
+ const std::vector<std::unique_ptr<QuicCryptoFrame>>& crypto_frames() const {
+ return crypto_frames_;
+ }
+ const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
+ return stop_waiting_frames_;
+ }
+ const std::vector<QuicPingFrame>& ping_frames() const { return ping_frames_; }
+ const std::vector<QuicMessageFrame>& message_frames() const {
+ return message_frames_;
+ }
+ const std::vector<QuicWindowUpdateFrame>& window_update_frames() const {
+ return window_update_frames_;
+ }
+ const std::vector<QuicPaddingFrame>& padding_frames() const {
+ return padding_frames_;
+ }
+ const std::vector<QuicPathChallengeFrame>& path_challenge_frames() const {
+ return path_challenge_frames_;
+ }
+ const std::vector<QuicPathResponseFrame>& path_response_frames() const {
+ return path_response_frames_;
+ }
+ const QuicVersionNegotiationPacket* version_negotiation_packet() const {
+ return version_negotiation_packet_.get();
+ }
+ EncryptionLevel last_decrypted_level() const { return last_decrypted_level_; }
+ const QuicEncryptedPacket* coalesced_packet() const {
+ return coalesced_packet_.get();
+ }
+
+ private:
+ QuicErrorCode error_;
+ bool has_header_;
+ QuicPacketHeader header_;
+ std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
+ std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
+ std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
+ std::vector<QuicAckFrame> ack_frames_;
+ std::vector<QuicStopWaitingFrame> stop_waiting_frames_;
+ std::vector<QuicPaddingFrame> padding_frames_;
+ std::vector<QuicPingFrame> ping_frames_;
+ std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames_;
+ std::vector<std::unique_ptr<QuicCryptoFrame>> crypto_frames_;
+ std::vector<QuicRstStreamFrame> rst_stream_frames_;
+ std::vector<QuicGoAwayFrame> goaway_frames_;
+ std::vector<QuicStreamsBlockedFrame> streams_blocked_frames_;
+ std::vector<QuicMaxStreamsFrame> max_streams_frames_;
+ std::vector<QuicConnectionCloseFrame> connection_close_frames_;
+ std::vector<QuicStopSendingFrame> stop_sending_frames_;
+ std::vector<QuicPathChallengeFrame> path_challenge_frames_;
+ std::vector<QuicPathResponseFrame> path_response_frames_;
+ std::vector<QuicWindowUpdateFrame> window_update_frames_;
+ std::vector<QuicBlockedFrame> blocked_frames_;
+ std::vector<QuicNewConnectionIdFrame> new_connection_id_frames_;
+ std::vector<QuicRetireConnectionIdFrame> retire_connection_id_frames_;
+ std::vector<QuicNewTokenFrame> new_token_frames_;
+ std::vector<QuicMessageFrame> message_frames_;
+ std::vector<QuicHandshakeDoneFrame> handshake_done_frames_;
+ std::vector<QuicAckFrequencyFrame> ack_frequency_frames_;
+ std::vector<std::unique_ptr<std::string>> stream_data_;
+ std::vector<std::unique_ptr<std::string>> crypto_data_;
+ EncryptionLevel last_decrypted_level_;
+ std::unique_ptr<QuicEncryptedPacket> coalesced_packet_;
+};
+
+SimpleQuicFramer::SimpleQuicFramer()
+ : framer_(AllSupportedVersions(),
+ QuicTime::Zero(),
+ Perspective::IS_SERVER,
+ kQuicDefaultConnectionIdLength) {}
+
+SimpleQuicFramer::SimpleQuicFramer(
+ const ParsedQuicVersionVector& supported_versions)
+ : framer_(supported_versions,
+ QuicTime::Zero(),
+ Perspective::IS_SERVER,
+ kQuicDefaultConnectionIdLength) {}
+
+SimpleQuicFramer::SimpleQuicFramer(
+ const ParsedQuicVersionVector& supported_versions,
+ Perspective perspective)
+ : framer_(supported_versions,
+ QuicTime::Zero(),
+ perspective,
+ kQuicDefaultConnectionIdLength) {}
+
+SimpleQuicFramer::~SimpleQuicFramer() {}
+
+bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
+ visitor_ = std::make_unique<SimpleFramerVisitor>();
+ framer_.set_visitor(visitor_.get());
+ return framer_.ProcessPacket(packet);
+}
+
+void SimpleQuicFramer::Reset() {
+ visitor_ = std::make_unique<SimpleFramerVisitor>();
+}
+
+const QuicPacketHeader& SimpleQuicFramer::header() const {
+ return visitor_->header();
+}
+
+const QuicVersionNegotiationPacket*
+SimpleQuicFramer::version_negotiation_packet() const {
+ return visitor_->version_negotiation_packet();
+}
+
+EncryptionLevel SimpleQuicFramer::last_decrypted_level() const {
+ return visitor_->last_decrypted_level();
+}
+
+QuicFramer* SimpleQuicFramer::framer() {
+ return &framer_;
+}
+
+size_t SimpleQuicFramer::num_frames() const {
+ return ack_frames().size() + goaway_frames().size() +
+ rst_stream_frames().size() + stop_waiting_frames().size() +
+ path_challenge_frames().size() + path_response_frames().size() +
+ stream_frames().size() + ping_frames().size() +
+ connection_close_frames().size() + padding_frames().size() +
+ crypto_frames().size();
+}
+
+const std::vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const {
+ return visitor_->ack_frames();
+}
+
+const std::vector<QuicStopWaitingFrame>& SimpleQuicFramer::stop_waiting_frames()
+ const {
+ return visitor_->stop_waiting_frames();
+}
+
+const std::vector<QuicPathChallengeFrame>&
+SimpleQuicFramer::path_challenge_frames() const {
+ return visitor_->path_challenge_frames();
+}
+const std::vector<QuicPathResponseFrame>&
+SimpleQuicFramer::path_response_frames() const {
+ return visitor_->path_response_frames();
+}
+
+const std::vector<QuicPingFrame>& SimpleQuicFramer::ping_frames() const {
+ return visitor_->ping_frames();
+}
+
+const std::vector<QuicMessageFrame>& SimpleQuicFramer::message_frames() const {
+ return visitor_->message_frames();
+}
+
+const std::vector<QuicWindowUpdateFrame>&
+SimpleQuicFramer::window_update_frames() const {
+ return visitor_->window_update_frames();
+}
+
+const std::vector<std::unique_ptr<QuicStreamFrame>>&
+SimpleQuicFramer::stream_frames() const {
+ return visitor_->stream_frames();
+}
+
+const std::vector<std::unique_ptr<QuicCryptoFrame>>&
+SimpleQuicFramer::crypto_frames() const {
+ return visitor_->crypto_frames();
+}
+
+const std::vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames()
+ const {
+ return visitor_->rst_stream_frames();
+}
+
+const std::vector<QuicGoAwayFrame>& SimpleQuicFramer::goaway_frames() const {
+ return visitor_->goaway_frames();
+}
+
+const std::vector<QuicConnectionCloseFrame>&
+SimpleQuicFramer::connection_close_frames() const {
+ return visitor_->connection_close_frames();
+}
+
+const std::vector<QuicPaddingFrame>& SimpleQuicFramer::padding_frames() const {
+ return visitor_->padding_frames();
+}
+
+const QuicEncryptedPacket* SimpleQuicFramer::coalesced_packet() const {
+ return visitor_->coalesced_packet();
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/simple_quic_framer.h b/quiche/quic/test_tools/simple_quic_framer.h
new file mode 100644
index 0000000..a748f4c
--- /dev/null
+++ b/quiche/quic/test_tools/simple_quic_framer.h
@@ -0,0 +1,70 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_QUIC_FRAMER_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMPLE_QUIC_FRAMER_H_
+
+#include <memory>
+#include <vector>
+
+#include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packets.h"
+
+namespace quic {
+
+struct QuicAckFrame;
+
+namespace test {
+
+class SimpleFramerVisitor;
+
+// Peer to make public a number of otherwise private QuicFramer methods.
+class SimpleQuicFramer {
+ public:
+ SimpleQuicFramer();
+ explicit SimpleQuicFramer(const ParsedQuicVersionVector& supported_versions);
+ SimpleQuicFramer(const ParsedQuicVersionVector& supported_versions,
+ Perspective perspective);
+ SimpleQuicFramer(const SimpleQuicFramer&) = delete;
+ SimpleQuicFramer& operator=(const SimpleQuicFramer&) = delete;
+ ~SimpleQuicFramer();
+
+ bool ProcessPacket(const QuicEncryptedPacket& packet);
+ void Reset();
+
+ const QuicPacketHeader& header() const;
+ size_t num_frames() const;
+ const std::vector<QuicAckFrame>& ack_frames() const;
+ const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const;
+ const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const;
+ const std::vector<QuicPathChallengeFrame>& path_challenge_frames() const;
+ const std::vector<QuicPathResponseFrame>& path_response_frames() const;
+ const std::vector<QuicPingFrame>& ping_frames() const;
+ const std::vector<QuicMessageFrame>& message_frames() const;
+ const std::vector<QuicWindowUpdateFrame>& window_update_frames() const;
+ const std::vector<QuicGoAwayFrame>& goaway_frames() const;
+ const std::vector<QuicRstStreamFrame>& rst_stream_frames() const;
+ const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const;
+ const std::vector<std::unique_ptr<QuicCryptoFrame>>& crypto_frames() const;
+ const std::vector<QuicPaddingFrame>& padding_frames() const;
+ const QuicVersionNegotiationPacket* version_negotiation_packet() const;
+ EncryptionLevel last_decrypted_level() const;
+ const QuicEncryptedPacket* coalesced_packet() const;
+
+ QuicFramer* framer();
+
+ void SetSupportedVersions(const ParsedQuicVersionVector& versions) {
+ framer_.SetSupportedVersions(versions);
+ }
+
+ private:
+ QuicFramer framer_;
+ std::unique_ptr<SimpleFramerVisitor> visitor_;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMPLE_QUIC_FRAMER_H_
diff --git a/quiche/quic/test_tools/simple_session_cache.cc b/quiche/quic/test_tools/simple_session_cache.cc
new file mode 100644
index 0000000..eafead3
--- /dev/null
+++ b/quiche/quic/test_tools/simple_session_cache.cc
@@ -0,0 +1,76 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simple_session_cache.h"
+#include <memory>
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+
+namespace quic {
+namespace test {
+
+void SimpleSessionCache::Insert(const QuicServerId& server_id,
+ bssl::UniquePtr<SSL_SESSION> session,
+ const TransportParameters& params,
+ const ApplicationState* application_state) {
+ auto it = cache_entries_.find(server_id);
+ if (it == cache_entries_.end()) {
+ it = cache_entries_.insert(std::make_pair(server_id, Entry())).first;
+ }
+ if (session != nullptr) {
+ it->second.session = std::move(session);
+ }
+ if (application_state != nullptr) {
+ it->second.application_state =
+ std::make_unique<ApplicationState>(*application_state);
+ }
+ it->second.params = std::make_unique<TransportParameters>(params);
+}
+
+std::unique_ptr<QuicResumptionState> SimpleSessionCache::Lookup(
+ const QuicServerId& server_id, QuicWallTime /*now*/,
+ const SSL_CTX* /*ctx*/) {
+ auto it = cache_entries_.find(server_id);
+ if (it == cache_entries_.end()) {
+ return nullptr;
+ }
+
+ if (!it->second.session) {
+ cache_entries_.erase(it);
+ return nullptr;
+ }
+
+ auto state = std::make_unique<QuicResumptionState>();
+ state->tls_session = std::move(it->second.session);
+ if (it->second.application_state != nullptr) {
+ state->application_state =
+ std::make_unique<ApplicationState>(*it->second.application_state);
+ }
+ state->transport_params =
+ std::make_unique<TransportParameters>(*it->second.params);
+ state->token = it->second.token;
+ return state;
+}
+
+void SimpleSessionCache::ClearEarlyData(const QuicServerId& /*server_id*/) {
+ // The simple session cache only stores 1 SSL ticket per entry, so no need to
+ // do anything here.
+}
+
+void SimpleSessionCache::OnNewTokenReceived(const QuicServerId& server_id,
+ absl::string_view token) {
+ auto it = cache_entries_.find(server_id);
+ if (it == cache_entries_.end()) {
+ return;
+ }
+ it->second.token = std::string(token);
+}
+
+void SimpleSessionCache::RemoveExpiredEntries(QuicWallTime /*now*/) {
+ // The simple session cache does not support removing expired entries.
+}
+
+void SimpleSessionCache::Clear() { cache_entries_.clear(); }
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/simple_session_cache.h b/quiche/quic/test_tools/simple_session_cache.h
new file mode 100644
index 0000000..343303a
--- /dev/null
+++ b/quiche/quic/test_tools/simple_session_cache.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_CACHE_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_CACHE_H_
+
+#include <memory>
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+#include "quiche/quic/core/crypto/transport_parameters.h"
+
+namespace quic {
+namespace test {
+
+// SimpleSessionCache provides a simple implementation of SessionCache that
+// stores only one QuicResumptionState per QuicServerId. No limit is placed on
+// the total number of entries in the cache. When Lookup is called, if a cache
+// entry exists for the provided QuicServerId, the entry will be removed from
+// the cached when it is returned.
+// TODO(fayang): Remove SimpleSessionCache by using QuicClientSessionCache.
+class SimpleSessionCache : public SessionCache {
+ public:
+ SimpleSessionCache() = default;
+ ~SimpleSessionCache() override = default;
+
+ void Insert(const QuicServerId& server_id,
+ bssl::UniquePtr<SSL_SESSION> session,
+ const TransportParameters& params,
+ const ApplicationState* application_state) override;
+ std::unique_ptr<QuicResumptionState> Lookup(const QuicServerId& server_id,
+ QuicWallTime now,
+ const SSL_CTX* ctx) override;
+ void ClearEarlyData(const QuicServerId& server_id) override;
+ void OnNewTokenReceived(const QuicServerId& server_id,
+ absl::string_view token) override;
+ void RemoveExpiredEntries(QuicWallTime now) override;
+ void Clear() override;
+
+ private:
+ struct Entry {
+ bssl::UniquePtr<SSL_SESSION> session;
+ std::unique_ptr<TransportParameters> params;
+ std::unique_ptr<ApplicationState> application_state;
+ std::string token;
+ };
+ std::map<QuicServerId, Entry> cache_entries_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_CACHE_H_
diff --git a/quiche/quic/test_tools/simple_session_notifier.cc b/quiche/quic/test_tools/simple_session_notifier.cc
new file mode 100644
index 0000000..acd249e
--- /dev/null
+++ b/quiche/quic/test_tools/simple_session_notifier.cc
@@ -0,0 +1,766 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simple_session_notifier.h"
+
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+
+namespace test {
+
+SimpleSessionNotifier::SimpleSessionNotifier(QuicConnection* connection)
+ : last_control_frame_id_(kInvalidControlFrameId),
+ least_unacked_(1),
+ least_unsent_(1),
+ connection_(connection) {}
+
+SimpleSessionNotifier::~SimpleSessionNotifier() {
+ while (!control_frames_.empty()) {
+ DeleteFrame(&control_frames_.front());
+ control_frames_.pop_front();
+ }
+}
+
+SimpleSessionNotifier::StreamState::StreamState()
+ : bytes_total(0),
+ bytes_sent(0),
+ fin_buffered(false),
+ fin_sent(false),
+ fin_outstanding(false),
+ fin_lost(false) {}
+
+SimpleSessionNotifier::StreamState::~StreamState() {}
+
+QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
+ QuicStreamId id,
+ QuicByteCount data_length,
+ StreamSendingState state) {
+ if (!stream_map_.contains(id)) {
+ stream_map_[id] = StreamState();
+ }
+ StreamState& stream_state = stream_map_.find(id)->second;
+ const bool had_buffered_data =
+ HasBufferedStreamData() || HasBufferedControlFrames();
+ QuicStreamOffset offset = stream_state.bytes_sent;
+ QUIC_DVLOG(1) << "WriteOrBuffer stream_id: " << id << " [" << offset << ", "
+ << offset + data_length << "), fin: " << (state != NO_FIN);
+ stream_state.bytes_total += data_length;
+ stream_state.fin_buffered = state != NO_FIN;
+ if (had_buffered_data) {
+ QUIC_DLOG(WARNING) << "Connection is write blocked";
+ return {0, false};
+ }
+ const size_t length = stream_state.bytes_total - stream_state.bytes_sent;
+ connection_->SetTransmissionType(NOT_RETRANSMISSION);
+ QuicConsumedData consumed =
+ connection_->SendStreamData(id, length, stream_state.bytes_sent, state);
+ QUIC_DVLOG(1) << "consumed: " << consumed;
+ OnStreamDataConsumed(id, stream_state.bytes_sent, consumed.bytes_consumed,
+ consumed.fin_consumed);
+ return consumed;
+}
+
+void SimpleSessionNotifier::OnStreamDataConsumed(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ bool fin) {
+ StreamState& state = stream_map_.find(id)->second;
+ if (QuicUtils::IsCryptoStreamId(connection_->transport_version(), id) &&
+ data_length > 0) {
+ crypto_bytes_transferred_[connection_->encryption_level()].Add(
+ offset, offset + data_length);
+ }
+ state.bytes_sent += data_length;
+ state.fin_sent = fin;
+ state.fin_outstanding = fin;
+}
+
+size_t SimpleSessionNotifier::WriteCryptoData(EncryptionLevel level,
+ QuicByteCount data_length,
+ QuicStreamOffset offset) {
+ crypto_state_[level].bytes_total += data_length;
+ size_t bytes_written =
+ connection_->SendCryptoData(level, data_length, offset);
+ crypto_state_[level].bytes_sent += bytes_written;
+ crypto_bytes_transferred_[level].Add(offset, offset + bytes_written);
+ return bytes_written;
+}
+
+void SimpleSessionNotifier::WriteOrBufferRstStream(
+ QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written) {
+ QUIC_DVLOG(1) << "Writing RST_STREAM_FRAME";
+ const bool had_buffered_data =
+ HasBufferedStreamData() || HasBufferedControlFrames();
+ control_frames_.emplace_back((QuicFrame(new QuicRstStreamFrame(
+ ++last_control_frame_id_, id, error, bytes_written))));
+ if (error != QUIC_STREAM_NO_ERROR) {
+ // Delete stream to avoid retransmissions.
+ stream_map_.erase(id);
+ }
+ if (had_buffered_data) {
+ QUIC_DLOG(WARNING) << "Connection is write blocked";
+ return;
+ }
+ WriteBufferedControlFrames();
+}
+
+void SimpleSessionNotifier::WriteOrBufferWindowUpate(
+ QuicStreamId id, QuicStreamOffset byte_offset) {
+ QUIC_DVLOG(1) << "Writing WINDOW_UPDATE";
+ const bool had_buffered_data =
+ HasBufferedStreamData() || HasBufferedControlFrames();
+ QuicControlFrameId control_frame_id = ++last_control_frame_id_;
+ control_frames_.emplace_back(
+ (QuicFrame(QuicWindowUpdateFrame(control_frame_id, id, byte_offset))));
+ if (had_buffered_data) {
+ QUIC_DLOG(WARNING) << "Connection is write blocked";
+ return;
+ }
+ WriteBufferedControlFrames();
+}
+
+void SimpleSessionNotifier::WriteOrBufferPing() {
+ QUIC_DVLOG(1) << "Writing PING_FRAME";
+ const bool had_buffered_data =
+ HasBufferedStreamData() || HasBufferedControlFrames();
+ control_frames_.emplace_back(
+ (QuicFrame(QuicPingFrame(++last_control_frame_id_))));
+ if (had_buffered_data) {
+ QUIC_DLOG(WARNING) << "Connection is write blocked";
+ return;
+ }
+ WriteBufferedControlFrames();
+}
+
+void SimpleSessionNotifier::WriteOrBufferAckFrequency(
+ const QuicAckFrequencyFrame& ack_frequency_frame) {
+ QUIC_DVLOG(1) << "Writing ACK_FREQUENCY";
+ const bool had_buffered_data =
+ HasBufferedStreamData() || HasBufferedControlFrames();
+ QuicControlFrameId control_frame_id = ++last_control_frame_id_;
+ control_frames_.emplace_back((
+ QuicFrame(new QuicAckFrequencyFrame(control_frame_id,
+ /*sequence_number=*/control_frame_id,
+ ack_frequency_frame.packet_tolerance,
+ ack_frequency_frame.max_ack_delay))));
+ if (had_buffered_data) {
+ QUIC_DLOG(WARNING) << "Connection is write blocked";
+ return;
+ }
+ WriteBufferedControlFrames();
+}
+
+void SimpleSessionNotifier::NeuterUnencryptedData() {
+ if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+ for (const auto& interval : crypto_bytes_transferred_[ENCRYPTION_INITIAL]) {
+ QuicCryptoFrame crypto_frame(ENCRYPTION_INITIAL, interval.min(),
+ interval.max() - interval.min());
+ OnFrameAcked(QuicFrame(&crypto_frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ }
+ return;
+ }
+ for (const auto& interval : crypto_bytes_transferred_[ENCRYPTION_INITIAL]) {
+ QuicStreamFrame stream_frame(
+ QuicUtils::GetCryptoStreamId(connection_->transport_version()), false,
+ interval.min(), interval.max() - interval.min());
+ OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ }
+}
+
+void SimpleSessionNotifier::OnCanWrite() {
+ if (connection_->framer().is_processing_packet()) {
+ // Do not write data in the middle of packet processing because rest
+ // frames in the packet may change the data to write. For example, lost
+ // data could be acknowledged. Also, connection is going to emit
+ // OnCanWrite signal post packet processing.
+ QUIC_BUG(simple_notifier_write_mid_packet_processing)
+ << "Try to write mid packet processing.";
+ return;
+ }
+ if (!RetransmitLostCryptoData() || !RetransmitLostControlFrames() ||
+ !RetransmitLostStreamData()) {
+ return;
+ }
+ if (!WriteBufferedCryptoData() || !WriteBufferedControlFrames()) {
+ return;
+ }
+ // Write new data.
+ for (const auto& pair : stream_map_) {
+ const auto& state = pair.second;
+ if (!StreamHasBufferedData(pair.first)) {
+ continue;
+ }
+
+ const size_t length = state.bytes_total - state.bytes_sent;
+ const bool can_bundle_fin =
+ state.fin_buffered && (state.bytes_sent + length == state.bytes_total);
+ connection_->SetTransmissionType(NOT_RETRANSMISSION);
+ QuicConnection::ScopedEncryptionLevelContext context(
+ connection_,
+ connection_->framer().GetEncryptionLevelToSendApplicationData());
+ QuicConsumedData consumed = connection_->SendStreamData(
+ pair.first, length, state.bytes_sent, can_bundle_fin ? FIN : NO_FIN);
+ QUIC_DVLOG(1) << "Tries to write stream_id: " << pair.first << " ["
+ << state.bytes_sent << ", " << state.bytes_sent + length
+ << "), fin: " << can_bundle_fin
+ << ", and consumed: " << consumed;
+ OnStreamDataConsumed(pair.first, state.bytes_sent, consumed.bytes_consumed,
+ consumed.fin_consumed);
+ if (length != consumed.bytes_consumed ||
+ (can_bundle_fin && !consumed.fin_consumed)) {
+ break;
+ }
+ }
+}
+
+void SimpleSessionNotifier::OnStreamReset(QuicStreamId id,
+ QuicRstStreamErrorCode error) {
+ if (error != QUIC_STREAM_NO_ERROR) {
+ // Delete stream to avoid retransmissions.
+ stream_map_.erase(id);
+ }
+}
+
+bool SimpleSessionNotifier::WillingToWrite() const {
+ QUIC_DVLOG(1) << "has_buffered_control_frames: " << HasBufferedControlFrames()
+ << " as_lost_control_frames: " << !lost_control_frames_.empty()
+ << " has_buffered_stream_data: " << HasBufferedStreamData()
+ << " has_lost_stream_data: " << HasLostStreamData();
+ return HasBufferedControlFrames() || !lost_control_frames_.empty() ||
+ HasBufferedStreamData() || HasLostStreamData();
+}
+
+QuicByteCount SimpleSessionNotifier::StreamBytesSent() const {
+ QuicByteCount bytes_sent = 0;
+ for (const auto& pair : stream_map_) {
+ const auto& state = pair.second;
+ bytes_sent += state.bytes_sent;
+ }
+ return bytes_sent;
+}
+
+QuicByteCount SimpleSessionNotifier::StreamBytesToSend() const {
+ QuicByteCount bytes_to_send = 0;
+ for (const auto& pair : stream_map_) {
+ const auto& state = pair.second;
+ bytes_to_send += (state.bytes_total - state.bytes_sent);
+ }
+ return bytes_to_send;
+}
+
+bool SimpleSessionNotifier::OnFrameAcked(const QuicFrame& frame,
+ QuicTime::Delta /*ack_delay_time*/,
+ QuicTime /*receive_timestamp*/) {
+ QUIC_DVLOG(1) << "Acking " << frame;
+ if (frame.type == CRYPTO_FRAME) {
+ StreamState* state = &crypto_state_[frame.crypto_frame->level];
+ QuicStreamOffset offset = frame.crypto_frame->offset;
+ QuicByteCount data_length = frame.crypto_frame->data_length;
+ QuicIntervalSet<QuicStreamOffset> newly_acked(offset, offset + data_length);
+ newly_acked.Difference(state->bytes_acked);
+ if (newly_acked.Empty()) {
+ return false;
+ }
+ state->bytes_acked.Add(offset, offset + data_length);
+ state->pending_retransmissions.Difference(offset, offset + data_length);
+ return true;
+ }
+ if (frame.type != STREAM_FRAME) {
+ return OnControlFrameAcked(frame);
+ }
+ if (!stream_map_.contains(frame.stream_frame.stream_id)) {
+ return false;
+ }
+ auto* state = &stream_map_.find(frame.stream_frame.stream_id)->second;
+ QuicStreamOffset offset = frame.stream_frame.offset;
+ QuicByteCount data_length = frame.stream_frame.data_length;
+ QuicIntervalSet<QuicStreamOffset> newly_acked(offset, offset + data_length);
+ newly_acked.Difference(state->bytes_acked);
+ const bool fin_newly_acked = frame.stream_frame.fin && state->fin_outstanding;
+ if (newly_acked.Empty() && !fin_newly_acked) {
+ return false;
+ }
+ state->bytes_acked.Add(offset, offset + data_length);
+ if (fin_newly_acked) {
+ state->fin_outstanding = false;
+ state->fin_lost = false;
+ }
+ state->pending_retransmissions.Difference(offset, offset + data_length);
+ return true;
+}
+
+void SimpleSessionNotifier::OnFrameLost(const QuicFrame& frame) {
+ QUIC_DVLOG(1) << "Losting " << frame;
+ if (frame.type == CRYPTO_FRAME) {
+ StreamState* state = &crypto_state_[frame.crypto_frame->level];
+ QuicStreamOffset offset = frame.crypto_frame->offset;
+ QuicByteCount data_length = frame.crypto_frame->data_length;
+ QuicIntervalSet<QuicStreamOffset> bytes_lost(offset, offset + data_length);
+ bytes_lost.Difference(state->bytes_acked);
+ if (bytes_lost.Empty()) {
+ return;
+ }
+ for (const auto& lost : bytes_lost) {
+ state->pending_retransmissions.Add(lost.min(), lost.max());
+ }
+ return;
+ }
+ if (frame.type != STREAM_FRAME) {
+ OnControlFrameLost(frame);
+ return;
+ }
+ if (!stream_map_.contains(frame.stream_frame.stream_id)) {
+ return;
+ }
+ auto* state = &stream_map_.find(frame.stream_frame.stream_id)->second;
+ QuicStreamOffset offset = frame.stream_frame.offset;
+ QuicByteCount data_length = frame.stream_frame.data_length;
+ QuicIntervalSet<QuicStreamOffset> bytes_lost(offset, offset + data_length);
+ bytes_lost.Difference(state->bytes_acked);
+ const bool fin_lost = state->fin_outstanding && frame.stream_frame.fin;
+ if (bytes_lost.Empty() && !fin_lost) {
+ return;
+ }
+ for (const auto& lost : bytes_lost) {
+ state->pending_retransmissions.Add(lost.min(), lost.max());
+ }
+ state->fin_lost = fin_lost;
+}
+
+bool SimpleSessionNotifier::RetransmitFrames(const QuicFrames& frames,
+ TransmissionType type) {
+ QuicConnection::ScopedPacketFlusher retransmission_flusher(connection_);
+ connection_->SetTransmissionType(type);
+ for (const QuicFrame& frame : frames) {
+ if (frame.type == CRYPTO_FRAME) {
+ const StreamState& state = crypto_state_[frame.crypto_frame->level];
+ const EncryptionLevel current_encryption_level =
+ connection_->encryption_level();
+ QuicIntervalSet<QuicStreamOffset> retransmission(
+ frame.crypto_frame->offset,
+ frame.crypto_frame->offset + frame.crypto_frame->data_length);
+ retransmission.Difference(state.bytes_acked);
+ for (const auto& interval : retransmission) {
+ QuicStreamOffset offset = interval.min();
+ QuicByteCount length = interval.max() - interval.min();
+ connection_->SetDefaultEncryptionLevel(frame.crypto_frame->level);
+ size_t consumed = connection_->SendCryptoData(frame.crypto_frame->level,
+ length, offset);
+ if (consumed < length) {
+ return false;
+ }
+ }
+ connection_->SetDefaultEncryptionLevel(current_encryption_level);
+ }
+ if (frame.type != STREAM_FRAME) {
+ if (GetControlFrameId(frame) == kInvalidControlFrameId) {
+ continue;
+ }
+ QuicFrame copy = CopyRetransmittableControlFrame(frame);
+ if (!connection_->SendControlFrame(copy)) {
+ // Connection is write blocked.
+ DeleteFrame(©);
+ return false;
+ }
+ continue;
+ }
+ if (!stream_map_.contains(frame.stream_frame.stream_id)) {
+ continue;
+ }
+ const auto& state = stream_map_.find(frame.stream_frame.stream_id)->second;
+ QuicIntervalSet<QuicStreamOffset> retransmission(
+ frame.stream_frame.offset,
+ frame.stream_frame.offset + frame.stream_frame.data_length);
+ EncryptionLevel retransmission_encryption_level =
+ connection_->encryption_level();
+ if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
+ frame.stream_frame.stream_id)) {
+ for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
+ if (retransmission.Intersects(crypto_bytes_transferred_[i])) {
+ retransmission_encryption_level = static_cast<EncryptionLevel>(i);
+ retransmission.Intersection(crypto_bytes_transferred_[i]);
+ break;
+ }
+ }
+ }
+ retransmission.Difference(state.bytes_acked);
+ bool retransmit_fin = frame.stream_frame.fin && state.fin_outstanding;
+ QuicConsumedData consumed(0, false);
+ for (const auto& interval : retransmission) {
+ QuicStreamOffset retransmission_offset = interval.min();
+ QuicByteCount retransmission_length = interval.max() - interval.min();
+ const bool can_bundle_fin =
+ retransmit_fin &&
+ (retransmission_offset + retransmission_length == state.bytes_sent);
+ QuicConnection::ScopedEncryptionLevelContext context(
+ connection_,
+ QuicUtils::IsCryptoStreamId(connection_->transport_version(),
+ frame.stream_frame.stream_id)
+ ? retransmission_encryption_level
+ : connection_->framer()
+ .GetEncryptionLevelToSendApplicationData());
+ consumed = connection_->SendStreamData(
+ frame.stream_frame.stream_id, retransmission_length,
+ retransmission_offset, can_bundle_fin ? FIN : NO_FIN);
+ QUIC_DVLOG(1) << "stream " << frame.stream_frame.stream_id
+ << " is forced to retransmit stream data ["
+ << retransmission_offset << ", "
+ << retransmission_offset + retransmission_length
+ << ") and fin: " << can_bundle_fin
+ << ", consumed: " << consumed;
+ if (can_bundle_fin) {
+ retransmit_fin = !consumed.fin_consumed;
+ }
+ if (consumed.bytes_consumed < retransmission_length ||
+ (can_bundle_fin && !consumed.fin_consumed)) {
+ // Connection is write blocked.
+ return false;
+ }
+ }
+ if (retransmit_fin) {
+ QUIC_DVLOG(1) << "stream " << frame.stream_frame.stream_id
+ << " retransmits fin only frame.";
+ consumed = connection_->SendStreamData(frame.stream_frame.stream_id, 0,
+ state.bytes_sent, FIN);
+ if (!consumed.fin_consumed) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+bool SimpleSessionNotifier::IsFrameOutstanding(const QuicFrame& frame) const {
+ if (frame.type == CRYPTO_FRAME) {
+ QuicStreamOffset offset = frame.crypto_frame->offset;
+ QuicByteCount data_length = frame.crypto_frame->data_length;
+ bool ret = data_length > 0 &&
+ !crypto_state_[frame.crypto_frame->level].bytes_acked.Contains(
+ offset, offset + data_length);
+ return ret;
+ }
+ if (frame.type != STREAM_FRAME) {
+ return IsControlFrameOutstanding(frame);
+ }
+ if (!stream_map_.contains(frame.stream_frame.stream_id)) {
+ return false;
+ }
+ const auto& state = stream_map_.find(frame.stream_frame.stream_id)->second;
+ QuicStreamOffset offset = frame.stream_frame.offset;
+ QuicByteCount data_length = frame.stream_frame.data_length;
+ return (data_length > 0 &&
+ !state.bytes_acked.Contains(offset, offset + data_length)) ||
+ (frame.stream_frame.fin && state.fin_outstanding);
+}
+
+bool SimpleSessionNotifier::HasUnackedCryptoData() const {
+ if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+ for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
+ const StreamState& state = crypto_state_[i];
+ if (state.bytes_total > state.bytes_sent) {
+ return true;
+ }
+ QuicIntervalSet<QuicStreamOffset> bytes_to_ack(0, state.bytes_total);
+ bytes_to_ack.Difference(state.bytes_acked);
+ if (!bytes_to_ack.Empty()) {
+ return true;
+ }
+ }
+ return false;
+ }
+ if (!stream_map_.contains(
+ QuicUtils::GetCryptoStreamId(connection_->transport_version()))) {
+ return false;
+ }
+ const auto& state =
+ stream_map_
+ .find(QuicUtils::GetCryptoStreamId(connection_->transport_version()))
+ ->second;
+ if (state.bytes_total > state.bytes_sent) {
+ return true;
+ }
+ QuicIntervalSet<QuicStreamOffset> bytes_to_ack(0, state.bytes_total);
+ bytes_to_ack.Difference(state.bytes_acked);
+ return !bytes_to_ack.Empty();
+}
+
+bool SimpleSessionNotifier::HasUnackedStreamData() const {
+ for (const auto& it : stream_map_) {
+ if (StreamIsWaitingForAcks(it.first))
+ return true;
+ }
+ return false;
+}
+
+bool SimpleSessionNotifier::OnControlFrameAcked(const QuicFrame& frame) {
+ QuicControlFrameId id = GetControlFrameId(frame);
+ if (id == kInvalidControlFrameId) {
+ return false;
+ }
+ QUICHE_DCHECK(id < least_unacked_ + control_frames_.size());
+ if (id < least_unacked_ ||
+ GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
+ kInvalidControlFrameId) {
+ return false;
+ }
+ SetControlFrameId(kInvalidControlFrameId,
+ &control_frames_.at(id - least_unacked_));
+ lost_control_frames_.erase(id);
+ while (!control_frames_.empty() &&
+ GetControlFrameId(control_frames_.front()) == kInvalidControlFrameId) {
+ DeleteFrame(&control_frames_.front());
+ control_frames_.pop_front();
+ ++least_unacked_;
+ }
+ return true;
+}
+
+void SimpleSessionNotifier::OnControlFrameLost(const QuicFrame& frame) {
+ QuicControlFrameId id = GetControlFrameId(frame);
+ if (id == kInvalidControlFrameId) {
+ return;
+ }
+ QUICHE_DCHECK(id < least_unacked_ + control_frames_.size());
+ if (id < least_unacked_ ||
+ GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
+ kInvalidControlFrameId) {
+ return;
+ }
+ if (!lost_control_frames_.contains(id)) {
+ lost_control_frames_[id] = true;
+ }
+}
+
+bool SimpleSessionNotifier::IsControlFrameOutstanding(
+ const QuicFrame& frame) const {
+ QuicControlFrameId id = GetControlFrameId(frame);
+ if (id == kInvalidControlFrameId) {
+ return false;
+ }
+ return id < least_unacked_ + control_frames_.size() && id >= least_unacked_ &&
+ GetControlFrameId(control_frames_.at(id - least_unacked_)) !=
+ kInvalidControlFrameId;
+}
+
+bool SimpleSessionNotifier::RetransmitLostControlFrames() {
+ while (!lost_control_frames_.empty()) {
+ QuicFrame pending = control_frames_.at(lost_control_frames_.begin()->first -
+ least_unacked_);
+ QuicFrame copy = CopyRetransmittableControlFrame(pending);
+ connection_->SetTransmissionType(LOSS_RETRANSMISSION);
+ if (!connection_->SendControlFrame(copy)) {
+ // Connection is write blocked.
+ DeleteFrame(©);
+ break;
+ }
+ lost_control_frames_.pop_front();
+ }
+ return lost_control_frames_.empty();
+}
+
+bool SimpleSessionNotifier::RetransmitLostCryptoData() {
+ if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+ for (EncryptionLevel level :
+ {ENCRYPTION_INITIAL, ENCRYPTION_HANDSHAKE, ENCRYPTION_ZERO_RTT,
+ ENCRYPTION_FORWARD_SECURE}) {
+ auto& state = crypto_state_[level];
+ while (!state.pending_retransmissions.Empty()) {
+ connection_->SetTransmissionType(HANDSHAKE_RETRANSMISSION);
+ EncryptionLevel current_encryption_level =
+ connection_->encryption_level();
+ connection_->SetDefaultEncryptionLevel(level);
+ QuicIntervalSet<QuicStreamOffset> retransmission(
+ state.pending_retransmissions.begin()->min(),
+ state.pending_retransmissions.begin()->max());
+ retransmission.Intersection(crypto_bytes_transferred_[level]);
+ QuicStreamOffset retransmission_offset = retransmission.begin()->min();
+ QuicByteCount retransmission_length =
+ retransmission.begin()->max() - retransmission.begin()->min();
+ size_t bytes_consumed = connection_->SendCryptoData(
+ level, retransmission_length, retransmission_offset);
+ // Restore encryption level.
+ connection_->SetDefaultEncryptionLevel(current_encryption_level);
+ state.pending_retransmissions.Difference(
+ retransmission_offset, retransmission_offset + bytes_consumed);
+ if (bytes_consumed < retransmission_length) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ if (!stream_map_.contains(
+ QuicUtils::GetCryptoStreamId(connection_->transport_version()))) {
+ return true;
+ }
+ auto& state =
+ stream_map_
+ .find(QuicUtils::GetCryptoStreamId(connection_->transport_version()))
+ ->second;
+ while (!state.pending_retransmissions.Empty()) {
+ connection_->SetTransmissionType(HANDSHAKE_RETRANSMISSION);
+ QuicIntervalSet<QuicStreamOffset> retransmission(
+ state.pending_retransmissions.begin()->min(),
+ state.pending_retransmissions.begin()->max());
+ EncryptionLevel retransmission_encryption_level = ENCRYPTION_INITIAL;
+ for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
+ if (retransmission.Intersects(crypto_bytes_transferred_[i])) {
+ retransmission_encryption_level = static_cast<EncryptionLevel>(i);
+ retransmission.Intersection(crypto_bytes_transferred_[i]);
+ break;
+ }
+ }
+ QuicStreamOffset retransmission_offset = retransmission.begin()->min();
+ QuicByteCount retransmission_length =
+ retransmission.begin()->max() - retransmission.begin()->min();
+ EncryptionLevel current_encryption_level = connection_->encryption_level();
+ // Set appropriate encryption level.
+ connection_->SetDefaultEncryptionLevel(retransmission_encryption_level);
+ QuicConsumedData consumed = connection_->SendStreamData(
+ QuicUtils::GetCryptoStreamId(connection_->transport_version()),
+ retransmission_length, retransmission_offset, NO_FIN);
+ // Restore encryption level.
+ connection_->SetDefaultEncryptionLevel(current_encryption_level);
+ state.pending_retransmissions.Difference(
+ retransmission_offset, retransmission_offset + consumed.bytes_consumed);
+ if (consumed.bytes_consumed < retransmission_length) {
+ break;
+ }
+ }
+ return state.pending_retransmissions.Empty();
+}
+
+bool SimpleSessionNotifier::RetransmitLostStreamData() {
+ for (auto& pair : stream_map_) {
+ StreamState& state = pair.second;
+ QuicConsumedData consumed(0, false);
+ while (!state.pending_retransmissions.Empty() || state.fin_lost) {
+ connection_->SetTransmissionType(LOSS_RETRANSMISSION);
+ if (state.pending_retransmissions.Empty()) {
+ QUIC_DVLOG(1) << "stream " << pair.first
+ << " retransmits fin only frame.";
+ consumed =
+ connection_->SendStreamData(pair.first, 0, state.bytes_sent, FIN);
+ state.fin_lost = !consumed.fin_consumed;
+ if (state.fin_lost) {
+ QUIC_DLOG(INFO) << "Connection is write blocked";
+ return false;
+ }
+ } else {
+ QuicStreamOffset offset = state.pending_retransmissions.begin()->min();
+ QuicByteCount length = state.pending_retransmissions.begin()->max() -
+ state.pending_retransmissions.begin()->min();
+ const bool can_bundle_fin =
+ state.fin_lost && (offset + length == state.bytes_sent);
+ consumed = connection_->SendStreamData(pair.first, length, offset,
+ can_bundle_fin ? FIN : NO_FIN);
+ QUIC_DVLOG(1) << "stream " << pair.first
+ << " tries to retransmit stream data [" << offset << ", "
+ << offset + length << ") and fin: " << can_bundle_fin
+ << ", consumed: " << consumed;
+ state.pending_retransmissions.Difference(
+ offset, offset + consumed.bytes_consumed);
+ if (consumed.fin_consumed) {
+ state.fin_lost = false;
+ }
+ if (length > consumed.bytes_consumed ||
+ (can_bundle_fin && !consumed.fin_consumed)) {
+ QUIC_DVLOG(1) << "Connection is write blocked";
+ break;
+ }
+ }
+ }
+ }
+ return !HasLostStreamData();
+}
+
+bool SimpleSessionNotifier::WriteBufferedCryptoData() {
+ for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
+ const StreamState& state = crypto_state_[i];
+ QuicIntervalSet<QuicStreamOffset> buffered_crypto_data(0,
+ state.bytes_total);
+ buffered_crypto_data.Difference(crypto_bytes_transferred_[i]);
+ for (const auto& interval : buffered_crypto_data) {
+ size_t bytes_written = connection_->SendCryptoData(
+ static_cast<EncryptionLevel>(i), interval.Length(), interval.min());
+ crypto_state_[i].bytes_sent += bytes_written;
+ crypto_bytes_transferred_[i].Add(interval.min(),
+ interval.min() + bytes_written);
+ if (bytes_written < interval.Length()) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+bool SimpleSessionNotifier::WriteBufferedControlFrames() {
+ while (HasBufferedControlFrames()) {
+ QuicFrame frame_to_send =
+ control_frames_.at(least_unsent_ - least_unacked_);
+ QuicFrame copy = CopyRetransmittableControlFrame(frame_to_send);
+ connection_->SetTransmissionType(NOT_RETRANSMISSION);
+ if (!connection_->SendControlFrame(copy)) {
+ // Connection is write blocked.
+ DeleteFrame(©);
+ break;
+ }
+ ++least_unsent_;
+ }
+ return !HasBufferedControlFrames();
+}
+
+bool SimpleSessionNotifier::HasBufferedControlFrames() const {
+ return least_unsent_ < least_unacked_ + control_frames_.size();
+}
+
+bool SimpleSessionNotifier::HasBufferedStreamData() const {
+ for (const auto& pair : stream_map_) {
+ const auto& state = pair.second;
+ if (state.bytes_total > state.bytes_sent ||
+ (state.fin_buffered && !state.fin_sent)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool SimpleSessionNotifier::StreamIsWaitingForAcks(QuicStreamId id) const {
+ if (!stream_map_.contains(id)) {
+ return false;
+ }
+ const StreamState& state = stream_map_.find(id)->second;
+ return !state.bytes_acked.Contains(0, state.bytes_sent) ||
+ state.fin_outstanding;
+}
+
+bool SimpleSessionNotifier::StreamHasBufferedData(QuicStreamId id) const {
+ if (!stream_map_.contains(id)) {
+ return false;
+ }
+ const StreamState& state = stream_map_.find(id)->second;
+ return state.bytes_total > state.bytes_sent ||
+ (state.fin_buffered && !state.fin_sent);
+}
+
+bool SimpleSessionNotifier::HasLostStreamData() const {
+ for (const auto& pair : stream_map_) {
+ const auto& state = pair.second;
+ if (!state.pending_retransmissions.Empty() || state.fin_lost) {
+ return true;
+ }
+ }
+ return false;
+}
+
+} // namespace test
+
+} // namespace quic
diff --git a/quiche/quic/test_tools/simple_session_notifier.h b/quiche/quic/test_tools/simple_session_notifier.h
new file mode 100644
index 0000000..a78fe1c
--- /dev/null
+++ b/quiche/quic/test_tools/simple_session_notifier.h
@@ -0,0 +1,170 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/core/quic_interval_set.h"
+#include "quiche/quic/core/session_notifier_interface.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/common/quiche_circular_deque.h"
+#include "quiche/common/quiche_linked_hash_map.h"
+
+namespace quic {
+
+class QuicConnection;
+
+namespace test {
+
+// SimpleSessionNotifier implements the basic functionalities of a session, and
+// it manages stream data and control frames.
+class SimpleSessionNotifier : public SessionNotifierInterface {
+ public:
+ explicit SimpleSessionNotifier(QuicConnection* connection);
+ ~SimpleSessionNotifier() override;
+
+ // Tries to write stream data and returns data consumed.
+ QuicConsumedData WriteOrBufferData(QuicStreamId id,
+ QuicByteCount data_length,
+ StreamSendingState state);
+
+ // Tries to write RST_STREAM_FRAME.
+ void WriteOrBufferRstStream(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written);
+
+ // Tries to write WINDOW_UPDATE.
+ void WriteOrBufferWindowUpate(QuicStreamId id, QuicStreamOffset byte_offset);
+
+ // Tries to write PING.
+ void WriteOrBufferPing();
+
+ // Tries to write ACK_FREQUENCY.
+ void WriteOrBufferAckFrequency(
+ const QuicAckFrequencyFrame& ack_frequency_frame);
+
+ // Tries to write CRYPTO data and returns the number of bytes written.
+ size_t WriteCryptoData(EncryptionLevel level,
+ QuicByteCount data_length,
+ QuicStreamOffset offset);
+
+ // Neuters unencrypted data of crypto stream.
+ void NeuterUnencryptedData();
+
+ // Called when connection_ becomes writable.
+ void OnCanWrite();
+
+ // Called to reset stream.
+ void OnStreamReset(QuicStreamId id, QuicRstStreamErrorCode error);
+
+ // Returns true if there are 1) unsent control frames and stream data, or 2)
+ // lost control frames and stream data.
+ bool WillingToWrite() const;
+
+ // Number of sent stream bytes. Please note, this does not count
+ // retransmissions.
+ QuicByteCount StreamBytesSent() const;
+
+ // Number of stream bytes waiting to be sent for the first time.
+ QuicByteCount StreamBytesToSend() const;
+
+ // Returns true if there is any stream data waiting to be sent for the first
+ // time.
+ bool HasBufferedStreamData() const;
+
+ // Returns true if stream |id| has any outstanding data.
+ bool StreamIsWaitingForAcks(QuicStreamId id) const;
+
+ // SessionNotifierInterface methods:
+ bool OnFrameAcked(const QuicFrame& frame,
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) override;
+ void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {}
+ void OnFrameLost(const QuicFrame& frame) override;
+ bool RetransmitFrames(const QuicFrames& frames,
+ TransmissionType type) override;
+ bool IsFrameOutstanding(const QuicFrame& frame) const override;
+ bool HasUnackedCryptoData() const override;
+ bool HasUnackedStreamData() const override;
+ bool HasLostStreamData() const;
+
+ private:
+ struct StreamState {
+ StreamState();
+ ~StreamState();
+
+ // Total number of bytes.
+ QuicByteCount bytes_total;
+ // Number of sent bytes.
+ QuicByteCount bytes_sent;
+ // Record of acked offsets.
+ QuicIntervalSet<QuicStreamOffset> bytes_acked;
+ // Data considered as lost and needs to be retransmitted.
+ QuicIntervalSet<QuicStreamOffset> pending_retransmissions;
+
+ bool fin_buffered;
+ bool fin_sent;
+ bool fin_outstanding;
+ bool fin_lost;
+ };
+
+ friend std::ostream& operator<<(std::ostream& os, const StreamState& s);
+
+ using StreamMap = absl::flat_hash_map<QuicStreamId, StreamState>;
+
+ void OnStreamDataConsumed(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ bool fin);
+
+ bool OnControlFrameAcked(const QuicFrame& frame);
+
+ void OnControlFrameLost(const QuicFrame& frame);
+
+ bool RetransmitLostControlFrames();
+
+ bool RetransmitLostCryptoData();
+
+ bool RetransmitLostStreamData();
+
+ bool WriteBufferedControlFrames();
+
+ bool WriteBufferedCryptoData();
+
+ bool IsControlFrameOutstanding(const QuicFrame& frame) const;
+
+ bool HasBufferedControlFrames() const;
+
+ bool StreamHasBufferedData(QuicStreamId id) const;
+
+ quiche::QuicheCircularDeque<QuicFrame> control_frames_;
+
+ quiche::QuicheLinkedHashMap<QuicControlFrameId, bool> lost_control_frames_;
+
+ // Id of latest saved control frame. 0 if no control frame has been saved.
+ QuicControlFrameId last_control_frame_id_;
+
+ // The control frame at the 0th index of control_frames_.
+ QuicControlFrameId least_unacked_;
+
+ // ID of the least unsent control frame.
+ QuicControlFrameId least_unsent_;
+
+ StreamMap stream_map_;
+
+ // Transferred crypto bytes according to encryption levels.
+ QuicIntervalSet<QuicStreamOffset>
+ crypto_bytes_transferred_[NUM_ENCRYPTION_LEVELS];
+
+ StreamState crypto_state_[NUM_ENCRYPTION_LEVELS];
+
+ QuicConnection* connection_;
+};
+
+} // namespace test
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
diff --git a/quiche/quic/test_tools/simple_session_notifier_test.cc b/quiche/quic/test_tools/simple_session_notifier_test.cc
new file mode 100644
index 0000000..77e3bf7
--- /dev/null
+++ b/quiche/quic/test_tools/simple_session_notifier_test.cc
@@ -0,0 +1,370 @@
+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simple_session_notifier.h"
+
+#include <utility>
+
+#include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simple_data_producer.h"
+
+using testing::_;
+using testing::InSequence;
+using testing::Return;
+using testing::StrictMock;
+
+namespace quic {
+namespace test {
+namespace {
+
+class MockQuicConnectionWithSendStreamData : public MockQuicConnection {
+ public:
+ MockQuicConnectionWithSendStreamData(MockQuicConnectionHelper* helper,
+ MockAlarmFactory* alarm_factory,
+ Perspective perspective)
+ : MockQuicConnection(helper, alarm_factory, perspective) {}
+
+ MOCK_METHOD(QuicConsumedData,
+ SendStreamData,
+ (QuicStreamId id,
+ size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state),
+ (override));
+};
+
+class SimpleSessionNotifierTest : public QuicTest {
+ public:
+ SimpleSessionNotifierTest()
+ : connection_(&helper_, &alarm_factory_, Perspective::IS_CLIENT),
+ notifier_(&connection_) {
+ connection_.set_visitor(&visitor_);
+ connection_.SetSessionNotifier(¬ifier_);
+ EXPECT_FALSE(notifier_.WillingToWrite());
+ EXPECT_EQ(0u, notifier_.StreamBytesSent());
+ EXPECT_FALSE(notifier_.HasBufferedStreamData());
+ }
+
+ bool ControlFrameConsumed(const QuicFrame& frame) {
+ DeleteFrame(&const_cast<QuicFrame&>(frame));
+ return true;
+ }
+
+ MockQuicConnectionHelper helper_;
+ MockAlarmFactory alarm_factory_;
+ MockQuicConnectionVisitor visitor_;
+ StrictMock<MockQuicConnectionWithSendStreamData> connection_;
+ SimpleSessionNotifier notifier_;
+};
+
+TEST_F(SimpleSessionNotifierTest, WriteOrBufferData) {
+ InSequence s;
+ EXPECT_CALL(connection_, SendStreamData(3, 1024, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(3, 1024, NO_FIN);
+ EXPECT_EQ(0u, notifier_.StreamBytesToSend());
+ EXPECT_CALL(connection_, SendStreamData(5, 512, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(512, false)));
+ notifier_.WriteOrBufferData(5, 512, NO_FIN);
+ EXPECT_FALSE(notifier_.WillingToWrite());
+ // Connection is blocked.
+ EXPECT_CALL(connection_, SendStreamData(5, 512, 512, FIN))
+ .WillOnce(Return(QuicConsumedData(256, false)));
+ notifier_.WriteOrBufferData(5, 512, FIN);
+ EXPECT_TRUE(notifier_.WillingToWrite());
+ EXPECT_EQ(1792u, notifier_.StreamBytesSent());
+ EXPECT_EQ(256u, notifier_.StreamBytesToSend());
+ EXPECT_TRUE(notifier_.HasBufferedStreamData());
+
+ // New data cannot be sent as connection is blocked.
+ EXPECT_CALL(connection_, SendStreamData(7, 1024, 0, FIN)).Times(0);
+ notifier_.WriteOrBufferData(7, 1024, FIN);
+ EXPECT_EQ(1792u, notifier_.StreamBytesSent());
+}
+
+TEST_F(SimpleSessionNotifierTest, WriteOrBufferRstStream) {
+ InSequence s;
+ EXPECT_CALL(connection_, SendStreamData(5, 1024, 0, FIN))
+ .WillOnce(Return(QuicConsumedData(1024, true)));
+ notifier_.WriteOrBufferData(5, 1024, FIN);
+ EXPECT_TRUE(notifier_.StreamIsWaitingForAcks(5));
+ EXPECT_TRUE(notifier_.HasUnackedStreamData());
+
+ // Reset stream 5 with no error.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillRepeatedly(
+ Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ notifier_.WriteOrBufferRstStream(5, QUIC_STREAM_NO_ERROR, 1024);
+ // Verify stream 5 is waiting for acks.
+ EXPECT_TRUE(notifier_.StreamIsWaitingForAcks(5));
+ EXPECT_TRUE(notifier_.HasUnackedStreamData());
+
+ // Reset stream 5 with error.
+ notifier_.WriteOrBufferRstStream(5, QUIC_ERROR_PROCESSING_STREAM, 1024);
+ EXPECT_FALSE(notifier_.StreamIsWaitingForAcks(5));
+ EXPECT_FALSE(notifier_.HasUnackedStreamData());
+}
+
+TEST_F(SimpleSessionNotifierTest, WriteOrBufferPing) {
+ InSequence s;
+ // Write ping when connection is not write blocked.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillRepeatedly(
+ Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ notifier_.WriteOrBufferPing();
+ EXPECT_EQ(0u, notifier_.StreamBytesToSend());
+ EXPECT_FALSE(notifier_.WillingToWrite());
+
+ // Write stream data and cause the connection to be write blocked.
+ EXPECT_CALL(connection_, SendStreamData(3, 1024, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(3, 1024, NO_FIN);
+ EXPECT_EQ(0u, notifier_.StreamBytesToSend());
+ EXPECT_CALL(connection_, SendStreamData(5, 512, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(256, false)));
+ notifier_.WriteOrBufferData(5, 512, NO_FIN);
+ EXPECT_TRUE(notifier_.WillingToWrite());
+
+ // Connection is blocked.
+ EXPECT_CALL(connection_, SendControlFrame(_)).Times(0);
+ notifier_.WriteOrBufferPing();
+}
+
+TEST_F(SimpleSessionNotifierTest, NeuterUnencryptedData) {
+ if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
+ // This test writes crypto data through crypto streams. It won't work when
+ // crypto frames are used instead.
+ return;
+ }
+ InSequence s;
+ // Send crypto data [0, 1024) in ENCRYPTION_INITIAL.
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 1024, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), 1024,
+ NO_FIN);
+ // Send crypto data [1024, 2048) in ENCRYPTION_ZERO_RTT.
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 1024, 1024, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), 1024,
+ NO_FIN);
+ // Ack [1024, 2048).
+ QuicStreamFrame stream_frame(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), false,
+ 1024, 1024);
+ notifier_.OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ EXPECT_TRUE(notifier_.StreamIsWaitingForAcks(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version())));
+ EXPECT_TRUE(notifier_.HasUnackedStreamData());
+
+ // Neuters unencrypted data.
+ notifier_.NeuterUnencryptedData();
+ EXPECT_FALSE(notifier_.StreamIsWaitingForAcks(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version())));
+ EXPECT_FALSE(notifier_.HasUnackedStreamData());
+}
+
+TEST_F(SimpleSessionNotifierTest, OnCanWrite) {
+ if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
+ // This test writes crypto data through crypto streams. It won't work when
+ // crypto frames are used instead.
+ return;
+ }
+ InSequence s;
+ // Send crypto data [0, 1024) in ENCRYPTION_INITIAL.
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 1024, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), 1024,
+ NO_FIN);
+
+ // Send crypto data [1024, 2048) in ENCRYPTION_ZERO_RTT.
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 1024, 1024, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(1024, false)));
+ notifier_.WriteOrBufferData(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), 1024,
+ NO_FIN);
+ // Send stream 3 [0, 1024) and connection is blocked.
+ EXPECT_CALL(connection_, SendStreamData(3, 1024, 0, FIN))
+ .WillOnce(Return(QuicConsumedData(512, false)));
+ notifier_.WriteOrBufferData(3, 1024, FIN);
+ // Send stream 5 [0, 1024).
+ EXPECT_CALL(connection_, SendStreamData(5, _, _, _)).Times(0);
+ notifier_.WriteOrBufferData(5, 1024, NO_FIN);
+ // Reset stream 5 with error.
+ EXPECT_CALL(connection_, SendControlFrame(_)).Times(0);
+ notifier_.WriteOrBufferRstStream(5, QUIC_ERROR_PROCESSING_STREAM, 1024);
+
+ // Lost crypto data [500, 1500) and stream 3 [0, 512).
+ QuicStreamFrame frame1(
+ QuicUtils::GetCryptoStreamId(connection_.transport_version()), false, 500,
+ 1000);
+ QuicStreamFrame frame2(3, false, 0, 512);
+ notifier_.OnFrameLost(QuicFrame(frame1));
+ notifier_.OnFrameLost(QuicFrame(frame2));
+
+ // Connection becomes writable.
+ // Lost crypto data gets retransmitted as [500, 1024) and [1024, 1500), as
+ // they are in different encryption levels.
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 524, 500, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(524, false)));
+ EXPECT_CALL(connection_, SendStreamData(QuicUtils::GetCryptoStreamId(
+ connection_.transport_version()),
+ 476, 1024, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(476, false)));
+ // Lost stream 3 data gets retransmitted.
+ EXPECT_CALL(connection_, SendStreamData(3, 512, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(512, false)));
+ // Buffered control frames get sent.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillOnce(Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ // Buffered stream 3 data [512, 1024) gets sent.
+ EXPECT_CALL(connection_, SendStreamData(3, 512, 512, FIN))
+ .WillOnce(Return(QuicConsumedData(512, true)));
+ notifier_.OnCanWrite();
+ EXPECT_FALSE(notifier_.WillingToWrite());
+}
+
+TEST_F(SimpleSessionNotifierTest, OnCanWriteCryptoFrames) {
+ if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
+ return;
+ }
+ SimpleDataProducer producer;
+ connection_.SetDataProducer(&producer);
+ InSequence s;
+ // Send crypto data [0, 1024) in ENCRYPTION_INITIAL.
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
+ EXPECT_CALL(connection_, SendCryptoData(ENCRYPTION_INITIAL, 1024, 0))
+ .WillOnce(Invoke(&connection_,
+ &MockQuicConnection::QuicConnection_SendCryptoData));
+ EXPECT_CALL(connection_, CloseConnection(QUIC_PACKET_WRITE_ERROR, _, _));
+ std::string crypto_data1(1024, 'a');
+ producer.SaveCryptoData(ENCRYPTION_INITIAL, 0, crypto_data1);
+ std::string crypto_data2(524, 'a');
+ producer.SaveCryptoData(ENCRYPTION_INITIAL, 500, crypto_data2);
+ notifier_.WriteCryptoData(ENCRYPTION_INITIAL, 1024, 0);
+ // Send crypto data [1024, 2048) in ENCRYPTION_ZERO_RTT.
+ connection_.SetEncrypter(ENCRYPTION_ZERO_RTT, std::make_unique<NullEncrypter>(
+ Perspective::IS_CLIENT));
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
+ EXPECT_CALL(connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 1024, 0))
+ .WillOnce(Invoke(&connection_,
+ &MockQuicConnection::QuicConnection_SendCryptoData));
+ std::string crypto_data3(1024, 'a');
+ producer.SaveCryptoData(ENCRYPTION_ZERO_RTT, 0, crypto_data3);
+ notifier_.WriteCryptoData(ENCRYPTION_ZERO_RTT, 1024, 0);
+ // Send stream 3 [0, 1024) and connection is blocked.
+ EXPECT_CALL(connection_, SendStreamData(3, 1024, 0, FIN))
+ .WillOnce(Return(QuicConsumedData(512, false)));
+ notifier_.WriteOrBufferData(3, 1024, FIN);
+ // Send stream 5 [0, 1024).
+ EXPECT_CALL(connection_, SendStreamData(5, _, _, _)).Times(0);
+ notifier_.WriteOrBufferData(5, 1024, NO_FIN);
+ // Reset stream 5 with error.
+ EXPECT_CALL(connection_, SendControlFrame(_)).Times(0);
+ notifier_.WriteOrBufferRstStream(5, QUIC_ERROR_PROCESSING_STREAM, 1024);
+
+ // Lost crypto data [500, 1500) and stream 3 [0, 512).
+ QuicCryptoFrame crypto_frame1(ENCRYPTION_INITIAL, 500, 524);
+ QuicCryptoFrame crypto_frame2(ENCRYPTION_ZERO_RTT, 0, 476);
+ QuicStreamFrame stream3_frame(3, false, 0, 512);
+ notifier_.OnFrameLost(QuicFrame(&crypto_frame1));
+ notifier_.OnFrameLost(QuicFrame(&crypto_frame2));
+ notifier_.OnFrameLost(QuicFrame(stream3_frame));
+
+ // Connection becomes writable.
+ // Lost crypto data gets retransmitted as [500, 1024) and [1024, 1500), as
+ // they are in different encryption levels.
+ EXPECT_CALL(connection_, SendCryptoData(ENCRYPTION_INITIAL, 524, 500))
+ .WillOnce(Invoke(&connection_,
+ &MockQuicConnection::QuicConnection_SendCryptoData));
+ EXPECT_CALL(connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 476, 0))
+ .WillOnce(Invoke(&connection_,
+ &MockQuicConnection::QuicConnection_SendCryptoData));
+ // Lost stream 3 data gets retransmitted.
+ EXPECT_CALL(connection_, SendStreamData(3, 512, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(512, false)));
+ // Buffered control frames get sent.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillOnce(Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ // Buffered stream 3 data [512, 1024) gets sent.
+ EXPECT_CALL(connection_, SendStreamData(3, 512, 512, FIN))
+ .WillOnce(Return(QuicConsumedData(512, true)));
+ notifier_.OnCanWrite();
+ EXPECT_FALSE(notifier_.WillingToWrite());
+}
+
+TEST_F(SimpleSessionNotifierTest, RetransmitFrames) {
+ InSequence s;
+ connection_.SetEncrypter(
+ ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
+ // Send stream 3 data [0, 10) and fin.
+ EXPECT_CALL(connection_, SendStreamData(3, 10, 0, FIN))
+ .WillOnce(Return(QuicConsumedData(10, true)));
+ notifier_.WriteOrBufferData(3, 10, FIN);
+ QuicStreamFrame frame1(3, true, 0, 10);
+ // Send stream 5 [0, 10) and fin.
+ EXPECT_CALL(connection_, SendStreamData(5, 10, 0, FIN))
+ .WillOnce(Return(QuicConsumedData(10, true)));
+ notifier_.WriteOrBufferData(5, 10, FIN);
+ QuicStreamFrame frame2(5, true, 0, 10);
+ // Reset stream 5 with no error.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillOnce(Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ notifier_.WriteOrBufferRstStream(5, QUIC_STREAM_NO_ERROR, 10);
+
+ // Ack stream 3 [3, 7), and stream 5 [8, 10).
+ QuicStreamFrame ack_frame1(3, false, 3, 4);
+ QuicStreamFrame ack_frame2(5, false, 8, 2);
+ notifier_.OnFrameAcked(QuicFrame(ack_frame1), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ notifier_.OnFrameAcked(QuicFrame(ack_frame2), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ EXPECT_FALSE(notifier_.WillingToWrite());
+
+ // Force to send.
+ QuicRstStreamFrame rst_stream(1, 5, QUIC_STREAM_NO_ERROR, 10);
+ QuicFrames frames;
+ frames.push_back(QuicFrame(frame2));
+ frames.push_back(QuicFrame(&rst_stream));
+ frames.push_back(QuicFrame(frame1));
+ // stream 5 data [0, 8), fin only are retransmitted.
+ EXPECT_CALL(connection_, SendStreamData(5, 8, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(8, false)));
+ EXPECT_CALL(connection_, SendStreamData(5, 0, 10, FIN))
+ .WillOnce(Return(QuicConsumedData(0, true)));
+ // rst_stream is retransmitted.
+ EXPECT_CALL(connection_, SendControlFrame(_))
+ .WillOnce(Invoke(this, &SimpleSessionNotifierTest::ControlFrameConsumed));
+ // stream 3 data [0, 3) is retransmitted and connection is blocked.
+ EXPECT_CALL(connection_, SendStreamData(3, 3, 0, NO_FIN))
+ .WillOnce(Return(QuicConsumedData(2, false)));
+ notifier_.RetransmitFrames(frames, RTO_RETRANSMISSION);
+ EXPECT_FALSE(notifier_.WillingToWrite());
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/README.md b/quiche/quic/test_tools/simulator/README.md
new file mode 100644
index 0000000..8582962
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/README.md
@@ -0,0 +1,99 @@
+# QUIC network simulator
+
+This directory contains a discrete event network simulator which QUIC code uses
+for testing congestion control and other transmission control code that requires
+a network simulation for tests on QuicConnection level of abstraction.
+
+## Actors
+
+The core of the simulator is the Simulator class, which maintains a virtual
+clock and an event queue. Any object in a simulation that needs to schedule
+events has to subclass Actor. Subclassing Actor involves:
+
+1. Calling the `Actor::Actor(Simulator*, std::string)` constructor to establish
+ the name of the object and the simulator it is associated with.
+2. Calling `Schedule(QuicTime)` to schedule the time at which `Act()` method is
+ called. `Schedule` will only cause the object to be rescheduled if the time
+ for which it is currently scheduled is later than the new time.
+3. Implementing `Act()` method with the relevant logic. The actor will be
+ removed from the event queue right before `Act()` is called.
+
+Here is a simple example of an object that outputs simulation time into the log
+every 100 ms.
+
+```c++
+class LogClock : public Actor {
+ public:
+ LogClock(Simulator* simulator, std::string name) : Actor(simulator, name) {
+ Schedule(clock_->Now());
+ }
+ ~LogClock() override {}
+
+ void Act() override {
+ QUIC_LOG(INFO) << "The current time is "
+ << clock_->Now().ToDebuggingValue();
+ Schedule(clock_->Now() + QuicTime::Delta::FromMilliseconds(100));
+ }
+};
+```
+
+A QuicAlarm object can be used to schedule events in the simulation using
+`Simulator::GetAlarmFactory()`.
+
+## Ports
+
+The simulated network transfers packets, which are modelled as an instance of
+struct `Packet`. A packet consists of source and destination address (which are
+just plain strings), a transmission timestamp and the UDP-layer payload.
+
+The simulation uses the push model: any object that wishes to transfer a packet
+to another component in the simulation has to explicitly do it itself. Any
+object that can accept a packet is called a *port*. There are two types of
+ports: unconstrained ports, which can always accept packets, and constrained
+ports, which signal when they can accept a new packet.
+
+An endpoint is an object that is connected to the network and can both receive
+and send packets. In our model, the endpoint always receives packets as an
+unconstrained port (*RX port*), and always writes packets to a constrained port
+(*TX port*).
+
+## Links
+
+The `SymmetricLink` class models a symmetric duplex links with finite bandwidth
+and propagation delay. It consists of a pair of identical `OneWayLink`s, which
+accept packets as a constrained port (where constrain comes from the finiteness
+of bandwidth) and outputs them into an unconstrained port. Two endpoints
+connected via a `SymmetricLink` look like this:
+
+```none
+ Endpoint A Endpoint B
++-----------+ SymmetricLink +-----------+
+| | +------------------------------+ | |
+| +---------+ | +------------------------+ | +---------+ |
+| | RX port <-----| OneWayLink *<-----| TX port | |
+| +---------+ | +------------------------+ | +---------+ |
+| | | | | |
+| +---------+ | +------------------------+ | +---------+ |
+| | TX port |----->* OneWayLink |-----> RX port | |
+| +---------+ | +------------------------+ | +---------+ |
+| | +------------------------------+ | |
++-----------+ +-----------+
+
+ ( -->* denotes constrained port)
+```
+
+In most common scenario, one of the endpoints is going to be a QUIC endpoint,
+and another is going to be a switch port.
+
+## Other objects
+
+Besides `SymmetricLink`, the simulator provides the following objects:
+
+* `Queue` allows to convert a constrained port into an unconstrained one by
+ buffering packets upon arrival. The queue has a finite size, and once the
+ queue is full, the packets are silently dropped.
+* `Switch` simulates a multi-port learning switch with a fixed queue for each
+ output port.
+* `QuicEndpoint` allows QuicConnection to be run over the simulated network.
+* `QuicEndpointMultiplexer` allows multiple connections to share the same
+ network endpoint.
diff --git a/quiche/quic/test_tools/simulator/actor.cc b/quiche/quic/test_tools/simulator/actor.cc
new file mode 100644
index 0000000..5d28cab
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/actor.cc
@@ -0,0 +1,31 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/actor.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+Actor::Actor(Simulator* simulator, std::string name)
+ : simulator_(simulator),
+ clock_(simulator->GetClock()),
+ name_(std::move(name)) {
+ simulator_->AddActor(this);
+}
+
+Actor::~Actor() {
+ simulator_->RemoveActor(this);
+}
+
+void Actor::Schedule(QuicTime next_tick) {
+ simulator_->Schedule(this, next_tick);
+}
+
+void Actor::Unschedule() {
+ simulator_->Unschedule(this);
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/actor.h b/quiche/quic/test_tools/simulator/actor.h
new file mode 100644
index 0000000..3747322
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/actor.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ACTOR_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ACTOR_H_
+
+#include <string>
+
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_time.h"
+
+namespace quic {
+namespace simulator {
+
+class Simulator;
+
+// Actor is the base class for all participants of the simulation which can
+// schedule events to be triggered at the specified time. Every actor has a
+// name assigned to it, which can be used for debugging and addressing purposes.
+//
+// The Actor object is scheduled as follows:
+// 1. Every Actor object appears at most once in the event queue, for one
+// specific time.
+// 2. Actor is scheduled by calling Schedule() method.
+// 3. If Schedule() method is called with multiple different times specified,
+// Act() method will be called at the earliest time specified.
+// 4. Before Act() is called, the Actor is removed from the event queue. Act()
+// will not be called again unless Schedule() is called.
+class Actor {
+ public:
+ Actor(Simulator* simulator, std::string name);
+ virtual ~Actor();
+
+ // Trigger all the events the actor can potentially handle at this point.
+ // Before Act() is called, the actor is removed from the event queue, and has
+ // to schedule the next call manually.
+ virtual void Act() = 0;
+
+ std::string name() const { return name_; }
+ Simulator* simulator() const { return simulator_; }
+
+ protected:
+ // Calls Schedule() on the associated simulator.
+ void Schedule(QuicTime next_tick);
+
+ // Calls Unschedule() on the associated simulator.
+ void Unschedule();
+
+ Simulator* simulator_;
+ const QuicClock* clock_;
+ std::string name_;
+
+ private:
+ // Since the Actor object registers itself with a simulator using a pointer to
+ // itself, do not allow it to be moved.
+ Actor(Actor&&) = delete;
+ Actor(const Actor&) = delete;
+ Actor& operator=(const Actor&) = delete;
+ Actor& operator=(Actor&&) = delete;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ACTOR_H_
diff --git a/quiche/quic/test_tools/simulator/alarm_factory.cc b/quiche/quic/test_tools/simulator/alarm_factory.cc
new file mode 100644
index 0000000..4c9f811
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/alarm_factory.cc
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/alarm_factory.h"
+
+#include "absl/strings/str_format.h"
+#include "quiche/quic/core/quic_alarm.h"
+
+namespace quic {
+namespace simulator {
+
+// Alarm is an implementation of QuicAlarm which can schedule alarms in the
+// simulation timeline.
+class Alarm : public QuicAlarm {
+ public:
+ Alarm(Simulator* simulator,
+ std::string name,
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+ : QuicAlarm(std::move(delegate)), adapter_(simulator, name, this) {}
+ ~Alarm() override {}
+
+ void SetImpl() override {
+ QUICHE_DCHECK(deadline().IsInitialized());
+ adapter_.Set(deadline());
+ }
+
+ void CancelImpl() override { adapter_.Cancel(); }
+
+ private:
+ // An adapter class triggering a QuicAlarm using a simulation time system.
+ // An adapter is required here because neither Actor nor QuicAlarm are pure
+ // interfaces.
+ class Adapter : public Actor {
+ public:
+ Adapter(Simulator* simulator, std::string name, Alarm* parent)
+ : Actor(simulator, name), parent_(parent) {}
+ ~Adapter() override {}
+
+ void Set(QuicTime time) { Schedule(std::max(time, clock_->Now())); }
+ void Cancel() { Unschedule(); }
+
+ void Act() override {
+ QUICHE_DCHECK(clock_->Now() >= parent_->deadline());
+ parent_->Fire();
+ }
+
+ private:
+ Alarm* parent_;
+ };
+ Adapter adapter_;
+};
+
+AlarmFactory::AlarmFactory(Simulator* simulator, std::string name)
+ : simulator_(simulator), name_(std::move(name)), counter_(0) {}
+
+AlarmFactory::~AlarmFactory() {}
+
+std::string AlarmFactory::GetNewAlarmName() {
+ ++counter_;
+ return absl::StrFormat("%s (alarm %i)", name_, counter_);
+}
+
+QuicAlarm* AlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
+ return new Alarm(simulator_, GetNewAlarmName(),
+ QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+}
+
+QuicArenaScopedPtr<QuicAlarm> AlarmFactory::CreateAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+ QuicConnectionArena* arena) {
+ if (arena != nullptr) {
+ return arena->New<Alarm>(simulator_, GetNewAlarmName(),
+ std::move(delegate));
+ }
+ return QuicArenaScopedPtr<QuicAlarm>(
+ new Alarm(simulator_, GetNewAlarmName(), std::move(delegate)));
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/alarm_factory.h b/quiche/quic/test_tools/simulator/alarm_factory.h
new file mode 100644
index 0000000..2d6f183
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/alarm_factory.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ALARM_FACTORY_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ALARM_FACTORY_H_
+
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/test_tools/simulator/actor.h"
+
+namespace quic {
+namespace simulator {
+
+// AlarmFactory allows to schedule QuicAlarms using the simulation event queue.
+class AlarmFactory : public QuicAlarmFactory {
+ public:
+ AlarmFactory(Simulator* simulator, std::string name);
+ AlarmFactory(const AlarmFactory&) = delete;
+ AlarmFactory& operator=(const AlarmFactory&) = delete;
+ ~AlarmFactory() override;
+
+ QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
+ QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
+ QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+ QuicConnectionArena* arena) override;
+
+ private:
+ // Automatically generate a name for a new alarm.
+ std::string GetNewAlarmName();
+
+ Simulator* simulator_;
+ std::string name_;
+ int counter_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_ALARM_FACTORY_H_
diff --git a/quiche/quic/test_tools/simulator/link.cc b/quiche/quic/test_tools/simulator/link.cc
new file mode 100644
index 0000000..ac2f56c
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/link.cc
@@ -0,0 +1,127 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/link.h"
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+// Parameters for random noise delay.
+const uint64_t kMaxRandomDelayUs = 10;
+
+OneWayLink::OneWayLink(Simulator* simulator,
+ std::string name,
+ UnconstrainedPortInterface* sink,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay)
+ : Actor(simulator, name),
+ sink_(sink),
+ bandwidth_(bandwidth),
+ propagation_delay_(propagation_delay),
+ next_write_at_(QuicTime::Zero()) {}
+
+OneWayLink::~OneWayLink() {}
+
+OneWayLink::QueuedPacket::QueuedPacket(std::unique_ptr<Packet> packet,
+ QuicTime dequeue_time)
+ : packet(std::move(packet)), dequeue_time(dequeue_time) {}
+
+OneWayLink::QueuedPacket::QueuedPacket(QueuedPacket&& other) = default;
+
+OneWayLink::QueuedPacket::~QueuedPacket() {}
+
+void OneWayLink::AcceptPacket(std::unique_ptr<Packet> packet) {
+ QUICHE_DCHECK(TimeUntilAvailable().IsZero());
+ QuicTime::Delta transfer_time = bandwidth_.TransferTime(packet->size);
+ next_write_at_ = clock_->Now() + transfer_time;
+
+ packets_in_transit_.emplace_back(
+ std::move(packet),
+ // Ensure that packets are delivered in order.
+ std::max(
+ next_write_at_ + propagation_delay_ + GetRandomDelay(transfer_time),
+ packets_in_transit_.empty()
+ ? QuicTime::Zero()
+ : packets_in_transit_.back().dequeue_time));
+ ScheduleNextPacketDeparture();
+}
+
+QuicTime::Delta OneWayLink::TimeUntilAvailable() {
+ const QuicTime now = clock_->Now();
+ if (next_write_at_ <= now) {
+ return QuicTime::Delta::Zero();
+ }
+
+ return next_write_at_ - now;
+}
+
+void OneWayLink::Act() {
+ QUICHE_DCHECK(!packets_in_transit_.empty());
+ QUICHE_DCHECK(packets_in_transit_.front().dequeue_time >= clock_->Now());
+
+ sink_->AcceptPacket(std::move(packets_in_transit_.front().packet));
+ packets_in_transit_.pop_front();
+
+ ScheduleNextPacketDeparture();
+}
+
+void OneWayLink::ScheduleNextPacketDeparture() {
+ if (packets_in_transit_.empty()) {
+ return;
+ }
+
+ Schedule(packets_in_transit_.front().dequeue_time);
+}
+
+QuicTime::Delta OneWayLink::GetRandomDelay(QuicTime::Delta transfer_time) {
+ if (!simulator_->enable_random_delays()) {
+ return QuicTime::Delta::Zero();
+ }
+
+ QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(
+ simulator_->GetRandomGenerator()->RandUint64() % (kMaxRandomDelayUs + 1));
+ // Have an upper bound on the delay to ensure packets do not go out of order.
+ delta = std::min(delta, transfer_time * 0.5);
+ return delta;
+}
+
+SymmetricLink::SymmetricLink(Simulator* simulator,
+ std::string name,
+ UnconstrainedPortInterface* sink_a,
+ UnconstrainedPortInterface* sink_b,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay)
+ : a_to_b_link_(simulator,
+ absl::StrCat(name, " (A-to-B)"),
+ sink_b,
+ bandwidth,
+ propagation_delay),
+ b_to_a_link_(simulator,
+ absl::StrCat(name, " (B-to-A)"),
+ sink_a,
+ bandwidth,
+ propagation_delay) {}
+
+SymmetricLink::SymmetricLink(Endpoint* endpoint_a,
+ Endpoint* endpoint_b,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay)
+ : SymmetricLink(endpoint_a->simulator(),
+ absl::StrFormat("Link [%s]<->[%s]",
+ endpoint_a->name(),
+ endpoint_b->name()),
+ endpoint_a->GetRxPort(),
+ endpoint_b->GetRxPort(),
+ bandwidth,
+ propagation_delay) {
+ endpoint_a->SetTxPort(&a_to_b_link_);
+ endpoint_b->SetTxPort(&b_to_a_link_);
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/link.h b/quiche/quic/test_tools/simulator/link.h
new file mode 100644
index 0000000..a534876
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/link.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_LINK_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_LINK_H_
+
+#include <utility>
+
+#include "quiche/quic/core/crypto/quic_random.h"
+#include "quiche/quic/core/quic_bandwidth.h"
+#include "quiche/quic/test_tools/simulator/actor.h"
+#include "quiche/quic/test_tools/simulator/port.h"
+#include "quiche/common/quiche_circular_deque.h"
+
+namespace quic {
+namespace simulator {
+
+// A reliable simplex link between two endpoints with constrained bandwidth. A
+// few microseconds of random delay are added for every packet to avoid
+// synchronization issues.
+class OneWayLink : public Actor, public ConstrainedPortInterface {
+ public:
+ OneWayLink(Simulator* simulator,
+ std::string name,
+ UnconstrainedPortInterface* sink,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay);
+ OneWayLink(const OneWayLink&) = delete;
+ OneWayLink& operator=(const OneWayLink&) = delete;
+ ~OneWayLink() override;
+
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+ QuicTime::Delta TimeUntilAvailable() override;
+ void Act() override;
+
+ QuicBandwidth bandwidth() const { return bandwidth_; }
+ void set_bandwidth(QuicBandwidth new_bandwidth) {
+ bandwidth_ = new_bandwidth;
+ }
+
+ protected:
+ // Get the value of a random delay imposed on each packet. By default, this
+ // is a short random delay in order to avoid artifical synchronization
+ // artifacts during the simulation. Subclasses may override this behavior
+ // (for example, to provide a random component of delay).
+ virtual QuicTime::Delta GetRandomDelay(QuicTime::Delta transfer_time);
+
+ private:
+ struct QueuedPacket {
+ std::unique_ptr<Packet> packet;
+ QuicTime dequeue_time;
+
+ QueuedPacket(std::unique_ptr<Packet> packet, QuicTime dequeue_time);
+ QueuedPacket(QueuedPacket&& other);
+ ~QueuedPacket();
+ };
+
+ // Schedule the next packet to be egressed out of the link if there are
+ // packets on the link.
+ void ScheduleNextPacketDeparture();
+
+ UnconstrainedPortInterface* sink_;
+ quiche::QuicheCircularDeque<QueuedPacket> packets_in_transit_;
+
+ QuicBandwidth bandwidth_;
+ const QuicTime::Delta propagation_delay_;
+
+ QuicTime next_write_at_;
+};
+
+// A full-duplex link between two endpoints, functionally equivalent to two
+// OneWayLink objects tied together.
+class SymmetricLink {
+ public:
+ SymmetricLink(Simulator* simulator,
+ std::string name,
+ UnconstrainedPortInterface* sink_a,
+ UnconstrainedPortInterface* sink_b,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay);
+ SymmetricLink(Endpoint* endpoint_a,
+ Endpoint* endpoint_b,
+ QuicBandwidth bandwidth,
+ QuicTime::Delta propagation_delay);
+ SymmetricLink(const SymmetricLink&) = delete;
+ SymmetricLink& operator=(const SymmetricLink&) = delete;
+
+ QuicBandwidth bandwidth() { return a_to_b_link_.bandwidth(); }
+ void set_bandwidth(QuicBandwidth new_bandwidth) {
+ a_to_b_link_.set_bandwidth(new_bandwidth);
+ b_to_a_link_.set_bandwidth(new_bandwidth);
+ }
+
+ private:
+ OneWayLink a_to_b_link_;
+ OneWayLink b_to_a_link_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_LINK_H_
diff --git a/quiche/quic/test_tools/simulator/packet_filter.cc b/quiche/quic/test_tools/simulator/packet_filter.cc
new file mode 100644
index 0000000..68f90b0
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/packet_filter.cc
@@ -0,0 +1,40 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/packet_filter.h"
+
+namespace quic {
+namespace simulator {
+
+PacketFilter::PacketFilter(Simulator* simulator,
+ std::string name,
+ Endpoint* input)
+ : Endpoint(simulator, name), input_(input) {
+ input_->SetTxPort(this);
+}
+
+PacketFilter::~PacketFilter() {}
+
+void PacketFilter::AcceptPacket(std::unique_ptr<Packet> packet) {
+ if (FilterPacket(*packet)) {
+ output_tx_port_->AcceptPacket(std::move(packet));
+ }
+}
+
+QuicTime::Delta PacketFilter::TimeUntilAvailable() {
+ return output_tx_port_->TimeUntilAvailable();
+}
+
+void PacketFilter::Act() {}
+
+UnconstrainedPortInterface* PacketFilter::GetRxPort() {
+ return input_->GetRxPort();
+}
+
+void PacketFilter::SetTxPort(ConstrainedPortInterface* port) {
+ output_tx_port_ = port;
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/packet_filter.h b/quiche/quic/test_tools/simulator/packet_filter.h
new file mode 100644
index 0000000..cf57bb0
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/packet_filter.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PACKET_FILTER_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PACKET_FILTER_H_
+
+#include "quiche/quic/test_tools/simulator/port.h"
+
+namespace quic {
+namespace simulator {
+
+// Packet filter allows subclasses to filter out the packets that enter the
+// input port and exit the output port. Packets in the other direction are
+// always passed through.
+//
+// The filter wraps around the input endpoint, and exposes the resulting
+// filtered endpoint via the output() method. For example, if initially there
+// are two endpoints, A and B, connected via a symmetric link:
+//
+// QuicEndpoint endpoint_a;
+// QuicEndpoint endpoint_b;
+//
+// [...]
+//
+// SymmetricLink a_b_link(&endpoint_a, &endpoint_b, ...);
+//
+// and the goal is to filter the traffic from A to B, then the new invocation
+// would be as follows:
+//
+// PacketFilter filter(&simulator, "A-to-B packet filter", endpoint_a);
+// SymmetricLink a_b_link(&filter, &endpoint_b, ...);
+//
+// Note that the filter drops the packet instanteneously, without it ever
+// reaching the output wire. This means that in a direct endpoint-to-endpoint
+// scenario, whenever the packet is dropped, the link would become immediately
+// available for the next packet.
+class PacketFilter : public Endpoint, public ConstrainedPortInterface {
+ public:
+ // Initialize the filter by wrapping around |input|. Does not take the
+ // ownership of |input|.
+ PacketFilter(Simulator* simulator, std::string name, Endpoint* input);
+ PacketFilter(const PacketFilter&) = delete;
+ PacketFilter& operator=(const PacketFilter&) = delete;
+ ~PacketFilter() override;
+
+ // Implementation of ConstrainedPortInterface.
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+ QuicTime::Delta TimeUntilAvailable() override;
+
+ // Implementation of Endpoint interface methods.
+ UnconstrainedPortInterface* GetRxPort() override;
+ void SetTxPort(ConstrainedPortInterface* port) override;
+
+ // Implementation of Actor interface methods.
+ void Act() override;
+
+ protected:
+ // Returns true if the packet should be passed through, and false if it should
+ // be dropped. The function is called once per packet, in the order that the
+ // packets arrive, so it is safe for the function to alter the internal state
+ // of the filter.
+ virtual bool FilterPacket(const Packet& packet) = 0;
+
+ private:
+ // The port onto which the filtered packets are egressed.
+ ConstrainedPortInterface* output_tx_port_;
+
+ // The original network endpoint wrapped by the class.
+ Endpoint* input_;
+};
+
+} // namespace simulator
+} // namespace quic
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PACKET_FILTER_H_
diff --git a/quiche/quic/test_tools/simulator/port.cc b/quiche/quic/test_tools/simulator/port.cc
new file mode 100644
index 0000000..bffc086
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/port.cc
@@ -0,0 +1,21 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/port.h"
+
+namespace quic {
+namespace simulator {
+
+Packet::Packet()
+ : source(), destination(), tx_timestamp(QuicTime::Zero()), size(0) {}
+
+Packet::~Packet() {}
+
+Packet::Packet(const Packet& packet) = default;
+
+Endpoint::Endpoint(Simulator* simulator, std::string name)
+ : Actor(simulator, name) {}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/port.h b/quiche/quic/test_tools/simulator/port.h
new file mode 100644
index 0000000..27bac95
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/port.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PORT_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PORT_H_
+
+#include <string>
+#include <utility>
+
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/test_tools/simulator/actor.h"
+
+namespace quic {
+namespace simulator {
+
+struct Packet {
+ Packet();
+ ~Packet();
+ Packet(const Packet& packet);
+
+ std::string source;
+ std::string destination;
+ QuicTime tx_timestamp;
+
+ std::string contents;
+ QuicByteCount size;
+};
+
+// An interface for anything that accepts packets at arbitrary rate.
+class UnconstrainedPortInterface {
+ public:
+ virtual ~UnconstrainedPortInterface() {}
+ virtual void AcceptPacket(std::unique_ptr<Packet> packet) = 0;
+};
+
+// An interface for any device that accepts packets at a specific rate.
+// Typically one would use a Queue object in order to write into a constrained
+// port.
+class ConstrainedPortInterface {
+ public:
+ virtual ~ConstrainedPortInterface() {}
+
+ // Accept a packet for a port. TimeUntilAvailable() must be zero before this
+ // method is called.
+ virtual void AcceptPacket(std::unique_ptr<Packet> packet) = 0;
+
+ // Time until write for the next port is available. Cannot be infinite.
+ virtual QuicTime::Delta TimeUntilAvailable() = 0;
+};
+
+// A convenience class for any network endpoints, i.e. the objects which can
+// both accept and send packets.
+class Endpoint : public Actor {
+ public:
+ virtual UnconstrainedPortInterface* GetRxPort() = 0;
+ virtual void SetTxPort(ConstrainedPortInterface* port) = 0;
+
+ protected:
+ Endpoint(Simulator* simulator, std::string name);
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_PORT_H_
diff --git a/quiche/quic/test_tools/simulator/queue.cc b/quiche/quic/test_tools/simulator/queue.cc
new file mode 100644
index 0000000..2af1ec1
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/queue.cc
@@ -0,0 +1,129 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/queue.h"
+
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+Queue::ListenerInterface::~ListenerInterface() {}
+
+Queue::Queue(Simulator* simulator, std::string name, QuicByteCount capacity)
+ : Actor(simulator, name),
+ capacity_(capacity),
+ bytes_queued_(0),
+ aggregation_threshold_(0),
+ aggregation_timeout_(QuicTime::Delta::Infinite()),
+ current_bundle_(0),
+ current_bundle_bytes_(0),
+ tx_port_(nullptr),
+ listener_(nullptr) {
+ aggregation_timeout_alarm_.reset(simulator_->GetAlarmFactory()->CreateAlarm(
+ new AggregationAlarmDelegate(this)));
+}
+
+Queue::~Queue() { aggregation_timeout_alarm_->PermanentCancel(); }
+
+void Queue::set_tx_port(ConstrainedPortInterface* port) {
+ tx_port_ = port;
+}
+
+void Queue::AcceptPacket(std::unique_ptr<Packet> packet) {
+ if (packet->size + bytes_queued_ > capacity_) {
+ QUIC_DVLOG(1) << "Queue [" << name() << "] has received a packet from ["
+ << packet->source << "] to [" << packet->destination
+ << "] which is over capacity. Dropping it.";
+ QUIC_DVLOG(1) << "Queue size: " << bytes_queued_ << " out of " << capacity_
+ << ". Packet size: " << packet->size;
+ return;
+ }
+
+ bytes_queued_ += packet->size;
+ queue_.emplace_back(std::move(packet), current_bundle_);
+
+ if (IsAggregationEnabled()) {
+ current_bundle_bytes_ += queue_.front().packet->size;
+ if (!aggregation_timeout_alarm_->IsSet()) {
+ aggregation_timeout_alarm_->Set(clock_->Now() + aggregation_timeout_);
+ }
+ if (current_bundle_bytes_ >= aggregation_threshold_) {
+ NextBundle();
+ }
+ }
+
+ ScheduleNextPacketDequeue();
+}
+
+void Queue::Act() {
+ QUICHE_DCHECK(!queue_.empty());
+ if (tx_port_->TimeUntilAvailable().IsZero()) {
+ QUICHE_DCHECK(bytes_queued_ >= queue_.front().packet->size);
+ bytes_queued_ -= queue_.front().packet->size;
+
+ tx_port_->AcceptPacket(std::move(queue_.front().packet));
+ queue_.pop_front();
+ if (listener_ != nullptr) {
+ listener_->OnPacketDequeued();
+ }
+ }
+
+ ScheduleNextPacketDequeue();
+}
+
+void Queue::EnableAggregation(QuicByteCount aggregation_threshold,
+ QuicTime::Delta aggregation_timeout) {
+ QUICHE_DCHECK_EQ(bytes_queued_, 0u);
+ QUICHE_DCHECK_GT(aggregation_threshold, 0u);
+ QUICHE_DCHECK(!aggregation_timeout.IsZero());
+ QUICHE_DCHECK(!aggregation_timeout.IsInfinite());
+
+ aggregation_threshold_ = aggregation_threshold;
+ aggregation_timeout_ = aggregation_timeout;
+}
+
+Queue::AggregationAlarmDelegate::AggregationAlarmDelegate(Queue* queue)
+ : queue_(queue) {}
+
+void Queue::AggregationAlarmDelegate::OnAlarm() {
+ queue_->NextBundle();
+ queue_->ScheduleNextPacketDequeue();
+}
+
+Queue::EnqueuedPacket::EnqueuedPacket(std::unique_ptr<Packet> packet,
+ AggregationBundleNumber bundle)
+ : packet(std::move(packet)), bundle(bundle) {}
+
+Queue::EnqueuedPacket::EnqueuedPacket(EnqueuedPacket&& other) = default;
+
+Queue::EnqueuedPacket::~EnqueuedPacket() = default;
+
+void Queue::NextBundle() {
+ current_bundle_++;
+ current_bundle_bytes_ = 0;
+ aggregation_timeout_alarm_->Cancel();
+}
+
+void Queue::ScheduleNextPacketDequeue() {
+ if (queue_.empty()) {
+ QUICHE_DCHECK_EQ(bytes_queued_, 0u);
+ return;
+ }
+
+ if (IsAggregationEnabled() && queue_.front().bundle == current_bundle_) {
+ return;
+ }
+
+ QuicTime::Delta time_until_available = QuicTime::Delta::Zero();
+ if (tx_port_) {
+ time_until_available = tx_port_->TimeUntilAvailable();
+ }
+
+ Schedule(clock_->Now() + time_until_available);
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/queue.h b/quiche/quic/test_tools/simulator/queue.h
new file mode 100644
index 0000000..b81db56
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/queue.h
@@ -0,0 +1,119 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUEUE_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUEUE_H_
+
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/test_tools/simulator/link.h"
+#include "quiche/common/quiche_circular_deque.h"
+
+namespace quic {
+namespace simulator {
+
+// A finitely sized queue which egresses packets onto a constrained link. The
+// capacity of the queue is measured in bytes as opposed to packets.
+class Queue : public Actor, public UnconstrainedPortInterface {
+ public:
+ class ListenerInterface {
+ public:
+ virtual ~ListenerInterface();
+
+ // Called whenever a packet is removed from the queue.
+ virtual void OnPacketDequeued() = 0;
+ };
+
+ Queue(Simulator* simulator, std::string name, QuicByteCount capacity);
+ Queue(const Queue&) = delete;
+ Queue& operator=(const Queue&) = delete;
+ ~Queue() override;
+
+ void set_tx_port(ConstrainedPortInterface* port);
+
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+
+ void Act() override;
+
+ QuicByteCount capacity() const { return capacity_; }
+ QuicByteCount bytes_queued() const { return bytes_queued_; }
+ QuicPacketCount packets_queued() const { return queue_.size(); }
+
+ void set_listener_interface(ListenerInterface* listener) {
+ listener_ = listener;
+ }
+
+ // Enables packet aggregation on the queue. Packet aggregation makes the
+ // queue bundle packets up until they reach certain size. When the
+ // aggregation is enabled, the packets are not dequeued until the total size
+ // of packets in the queue reaches |aggregation_threshold|. The packets are
+ // automatically flushed from the queue if the oldest packet has been in it
+ // for |aggregation_timeout|.
+ //
+ // This method may only be called when the queue is empty. Once enabled,
+ // aggregation cannot be disabled.
+ void EnableAggregation(QuicByteCount aggregation_threshold,
+ QuicTime::Delta aggregation_timeout);
+
+ private:
+ using AggregationBundleNumber = uint64_t;
+
+ // In order to implement packet aggregation, each packet is tagged with a
+ // bundle number. The queue keeps a bundle counter, and whenever a bundle is
+ // ready, it increments the number of the current bundle. Only the packets
+ // outside of the current bundle are allowed to leave the queue.
+ struct EnqueuedPacket {
+ EnqueuedPacket(std::unique_ptr<Packet> packet,
+ AggregationBundleNumber bundle);
+ EnqueuedPacket(EnqueuedPacket&& other);
+ ~EnqueuedPacket();
+
+ std::unique_ptr<Packet> packet;
+ AggregationBundleNumber bundle;
+ };
+
+ // Alarm handler for aggregation timeout.
+ class AggregationAlarmDelegate : public QuicAlarm::DelegateWithoutContext {
+ public:
+ explicit AggregationAlarmDelegate(Queue* queue);
+
+ void OnAlarm() override;
+
+ private:
+ Queue* queue_;
+ };
+
+ bool IsAggregationEnabled() const { return aggregation_threshold_ > 0; }
+
+ // Increment the bundle counter and reset the bundle state. This causes all
+ // packets currently in the bundle to be flushed onto the link.
+ void NextBundle();
+
+ void ScheduleNextPacketDequeue();
+
+ const QuicByteCount capacity_;
+ QuicByteCount bytes_queued_;
+
+ QuicByteCount aggregation_threshold_;
+ QuicTime::Delta aggregation_timeout_;
+ // The number of the current aggregation bundle. Monotonically increasing.
+ // All packets in the previous bundles are allowed to leave the queue, and
+ // none of the packets in the current one are.
+ AggregationBundleNumber current_bundle_;
+ // Size of the current bundle. Whenever it exceeds |aggregation_threshold_|,
+ // the next bundle is created.
+ QuicByteCount current_bundle_bytes_;
+ // Alarm responsible for flushing the current bundle upon timeout. Set when
+ // the first packet in the bundle is enqueued.
+ std::unique_ptr<QuicAlarm> aggregation_timeout_alarm_;
+
+ ConstrainedPortInterface* tx_port_;
+ quiche::QuicheCircularDeque<EnqueuedPacket> queue_;
+
+ ListenerInterface* listener_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUEUE_H_
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.cc b/quiche/quic/test_tools/simulator/quic_endpoint.cc
new file mode 100644
index 0000000..75194aa
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/quic_endpoint.cc
@@ -0,0 +1,258 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/quic_endpoint.h"
+
+#include <memory>
+#include <utility>
+
+#include "quiche/quic/core/crypto/crypto_handshake_message.h"
+#include "quiche/quic/core/crypto/crypto_protocol.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/platform/api/quic_test_output.h"
+#include "quiche/quic/test_tools/quic_config_peer.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+const QuicStreamId kDataStream = 3;
+const QuicByteCount kWriteChunkSize = 128 * 1024;
+const char kStreamDataContents = 'Q';
+
+QuicEndpoint::QuicEndpoint(Simulator* simulator,
+ std::string name,
+ std::string peer_name,
+ Perspective perspective,
+ QuicConnectionId connection_id)
+ : QuicEndpointBase(simulator, name, peer_name),
+ bytes_to_transfer_(0),
+ bytes_transferred_(0),
+ wrong_data_received_(false),
+ notifier_(nullptr) {
+ connection_ = std::make_unique<QuicConnection>(
+ connection_id, GetAddressFromName(name), GetAddressFromName(peer_name),
+ simulator, simulator->GetAlarmFactory(), &writer_, false, perspective,
+ ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
+ connection_->set_visitor(this);
+ connection_->SetEncrypter(ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<NullEncrypter>(perspective));
+ connection_->SetEncrypter(ENCRYPTION_INITIAL, nullptr);
+ if (connection_->version().KnowsWhichDecrypterToUse()) {
+ connection_->InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<NullDecrypter>(perspective));
+ connection_->RemoveDecrypter(ENCRYPTION_INITIAL);
+ } else {
+ connection_->SetDecrypter(ENCRYPTION_FORWARD_SECURE,
+ std::make_unique<NullDecrypter>(perspective));
+ }
+ connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
+ connection_->OnHandshakeComplete();
+ if (perspective == Perspective::IS_SERVER) {
+ // Skip version negotiation.
+ test::QuicConnectionPeer::SetNegotiatedVersion(connection_.get());
+ }
+ test::QuicConnectionPeer::SetAddressValidated(connection_.get());
+ connection_->SetDataProducer(&producer_);
+ connection_->SetSessionNotifier(this);
+ notifier_ = std::make_unique<test::SimpleSessionNotifier>(connection_.get());
+
+ // Configure the connection as if it received a handshake. This is important
+ // primarily because
+ // - this enables pacing, and
+ // - this sets the non-handshake timeouts.
+ std::string error;
+ CryptoHandshakeMessage peer_hello;
+ peer_hello.SetValue(kICSL,
+ static_cast<uint32_t>(kMaximumIdleTimeoutSecs - 1));
+ peer_hello.SetValue(kMIBS,
+ static_cast<uint32_t>(kDefaultMaxStreamsPerConnection));
+ QuicConfig config;
+ QuicErrorCode error_code = config.ProcessPeerHello(
+ peer_hello, perspective == Perspective::IS_CLIENT ? SERVER : CLIENT,
+ &error);
+ QUICHE_DCHECK_EQ(error_code, QUIC_NO_ERROR)
+ << "Configuration failed: " << error;
+ if (connection_->version().UsesTls()) {
+ if (connection_->perspective() == Perspective::IS_CLIENT) {
+ test::QuicConfigPeer::SetReceivedOriginalConnectionId(
+ &config, connection_->connection_id());
+ test::QuicConfigPeer::SetReceivedInitialSourceConnectionId(
+ &config, connection_->connection_id());
+ } else {
+ test::QuicConfigPeer::SetReceivedInitialSourceConnectionId(
+ &config, connection_->client_connection_id());
+ }
+ }
+ connection_->SetFromConfig(config);
+ connection_->DisableMtuDiscovery();
+}
+
+QuicByteCount QuicEndpoint::bytes_received() const {
+ QuicByteCount total = 0;
+ for (auto& interval : offsets_received_) {
+ total += interval.max() - interval.min();
+ }
+ return total;
+}
+
+QuicByteCount QuicEndpoint::bytes_to_transfer() const {
+ if (notifier_ != nullptr) {
+ return notifier_->StreamBytesToSend();
+ }
+ return bytes_to_transfer_;
+}
+
+QuicByteCount QuicEndpoint::bytes_transferred() const {
+ if (notifier_ != nullptr) {
+ return notifier_->StreamBytesSent();
+ }
+ return bytes_transferred_;
+}
+
+void QuicEndpoint::AddBytesToTransfer(QuicByteCount bytes) {
+ if (notifier_ != nullptr) {
+ if (notifier_->HasBufferedStreamData()) {
+ Schedule(clock_->Now());
+ }
+ notifier_->WriteOrBufferData(kDataStream, bytes, NO_FIN);
+ return;
+ }
+
+ if (bytes_to_transfer_ > 0) {
+ Schedule(clock_->Now());
+ }
+
+ bytes_to_transfer_ += bytes;
+ WriteStreamData();
+}
+
+void QuicEndpoint::OnStreamFrame(const QuicStreamFrame& frame) {
+ // Verify that the data received always matches the expected.
+ QUICHE_DCHECK(frame.stream_id == kDataStream);
+ for (size_t i = 0; i < frame.data_length; i++) {
+ if (frame.data_buffer[i] != kStreamDataContents) {
+ wrong_data_received_ = true;
+ }
+ }
+ offsets_received_.Add(frame.offset, frame.offset + frame.data_length);
+ // Sanity check against very pathological connections.
+ QUICHE_DCHECK_LE(offsets_received_.Size(), 1000u);
+}
+
+void QuicEndpoint::OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {}
+
+void QuicEndpoint::OnCanWrite() {
+ if (notifier_ != nullptr) {
+ notifier_->OnCanWrite();
+ return;
+ }
+ WriteStreamData();
+}
+
+bool QuicEndpoint::SendProbingData() {
+ if (connection()->sent_packet_manager().MaybeRetransmitOldestPacket(
+ PROBING_RETRANSMISSION)) {
+ return true;
+ }
+ return false;
+}
+
+bool QuicEndpoint::WillingAndAbleToWrite() const {
+ if (notifier_ != nullptr) {
+ return notifier_->WillingToWrite();
+ }
+ return bytes_to_transfer_ != 0;
+}
+bool QuicEndpoint::ShouldKeepConnectionAlive() const {
+ return true;
+}
+
+bool QuicEndpoint::AllowSelfAddressChange() const {
+ return false;
+}
+
+bool QuicEndpoint::OnFrameAcked(const QuicFrame& frame,
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) {
+ if (notifier_ != nullptr) {
+ return notifier_->OnFrameAcked(frame, ack_delay_time, receive_timestamp);
+ }
+ return false;
+}
+
+void QuicEndpoint::OnFrameLost(const QuicFrame& frame) {
+ QUICHE_DCHECK(notifier_);
+ notifier_->OnFrameLost(frame);
+}
+
+bool QuicEndpoint::RetransmitFrames(const QuicFrames& frames,
+ TransmissionType type) {
+ QUICHE_DCHECK(notifier_);
+ return notifier_->RetransmitFrames(frames, type);
+}
+
+bool QuicEndpoint::IsFrameOutstanding(const QuicFrame& frame) const {
+ QUICHE_DCHECK(notifier_);
+ return notifier_->IsFrameOutstanding(frame);
+}
+
+bool QuicEndpoint::HasUnackedCryptoData() const {
+ return false;
+}
+
+bool QuicEndpoint::HasUnackedStreamData() const {
+ if (notifier_ != nullptr) {
+ return notifier_->HasUnackedStreamData();
+ }
+ return false;
+}
+
+HandshakeState QuicEndpoint::GetHandshakeState() const {
+ return HANDSHAKE_COMPLETE;
+}
+
+WriteStreamDataResult QuicEndpoint::DataProducer::WriteStreamData(
+ QuicStreamId /*id*/,
+ QuicStreamOffset /*offset*/,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) {
+ writer->WriteRepeatedByte(kStreamDataContents, data_length);
+ return WRITE_SUCCESS;
+}
+
+bool QuicEndpoint::DataProducer::WriteCryptoData(EncryptionLevel /*level*/,
+ QuicStreamOffset /*offset*/,
+ QuicByteCount /*data_length*/,
+ QuicDataWriter* /*writer*/) {
+ QUIC_BUG(quic_bug_10157_1)
+ << "QuicEndpoint::DataProducer::WriteCryptoData is unimplemented";
+ return false;
+}
+
+void QuicEndpoint::WriteStreamData() {
+ // Instantiate a flusher which would normally be here due to QuicSession.
+ QuicConnection::ScopedPacketFlusher flusher(connection_.get());
+
+ while (bytes_to_transfer_ > 0) {
+ // Transfer data in chunks of size at most |kWriteChunkSize|.
+ const size_t transmission_size =
+ std::min(kWriteChunkSize, bytes_to_transfer_);
+
+ QuicConsumedData consumed_data = connection_->SendStreamData(
+ kDataStream, transmission_size, bytes_transferred_, NO_FIN);
+
+ QUICHE_DCHECK(consumed_data.bytes_consumed <= transmission_size);
+ bytes_transferred_ += consumed_data.bytes_consumed;
+ bytes_to_transfer_ -= consumed_data.bytes_consumed;
+ if (consumed_data.bytes_consumed != transmission_size) {
+ return;
+ }
+ }
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.h b/quiche/quic/test_tools/simulator/quic_endpoint.h
new file mode 100644
index 0000000..e29d594
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/quic_endpoint.h
@@ -0,0 +1,179 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/crypto/null_decrypter.h"
+#include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_default_packet_writer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_stream_frame_data_producer.h"
+#include "quiche/quic/core/quic_trace_visitor.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/test_tools/simple_session_notifier.h"
+#include "quiche/quic/test_tools/simulator/link.h"
+#include "quiche/quic/test_tools/simulator/queue.h"
+#include "quiche/quic/test_tools/simulator/quic_endpoint_base.h"
+
+namespace quic {
+namespace simulator {
+
+// A QUIC connection endpoint. Wraps around QuicConnection. In order to
+// initiate a transfer, the caller has to call AddBytesToTransfer(). The data
+// transferred is always the same and is always transferred on a single stream.
+// The endpoint receives all packets addressed to it, and verifies that the data
+// received is what it's supposed to be.
+class QuicEndpoint : public QuicEndpointBase,
+ public QuicConnectionVisitorInterface,
+ public SessionNotifierInterface {
+ public:
+ QuicEndpoint(Simulator* simulator,
+ std::string name,
+ std::string peer_name,
+ Perspective perspective,
+ QuicConnectionId connection_id);
+
+ QuicByteCount bytes_to_transfer() const;
+ QuicByteCount bytes_transferred() const;
+ QuicByteCount bytes_received() const;
+ bool wrong_data_received() const { return wrong_data_received_; }
+
+ // Send |bytes| bytes. Initiates the transfer if one is not already in
+ // progress.
+ void AddBytesToTransfer(QuicByteCount bytes);
+
+ // Begin QuicConnectionVisitorInterface implementation.
+ void OnStreamFrame(const QuicStreamFrame& frame) override;
+ void OnCryptoFrame(const QuicCryptoFrame& frame) override;
+ void OnCanWrite() override;
+ bool SendProbingData() override;
+ bool ValidateStatelessReset(
+ const quic::QuicSocketAddress& /*self_address*/,
+ const quic::QuicSocketAddress& /*peer_address*/) override {
+ return true;
+ }
+ bool WillingAndAbleToWrite() const override;
+ bool ShouldKeepConnectionAlive() const override;
+
+ std::string GetStreamsInfoForLogging() const override { return ""; }
+ void OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {}
+ void OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {}
+ void OnRstStream(const QuicRstStreamFrame& /*frame*/) override {}
+ void OnGoAway(const QuicGoAwayFrame& /*frame*/) override {}
+ void OnMessageReceived(absl::string_view /*message*/) override {}
+ void OnHandshakeDoneReceived() override {}
+ void OnNewTokenReceived(absl::string_view /*token*/) override {}
+ void OnConnectionClosed(const QuicConnectionCloseFrame& /*frame*/,
+ ConnectionCloseSource /*source*/) override {}
+ void OnWriteBlocked() override {}
+ void OnSuccessfulVersionNegotiation(
+ const ParsedQuicVersion& /*version*/) override {}
+ void OnPacketReceived(const QuicSocketAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/,
+ bool /*is_connectivity_probe*/) override {}
+ void OnCongestionWindowChange(QuicTime /*now*/) override {}
+ void OnConnectionMigration(AddressChangeType /*type*/) override {}
+ void OnPathDegrading() override {}
+ void OnForwardProgressMadeAfterPathDegrading() override {}
+ void OnAckNeedsRetransmittableFrame() override {}
+ void SendAckFrequency(const QuicAckFrequencyFrame& /*frame*/) override {}
+ void SendNewConnectionId(const QuicNewConnectionIdFrame& /*frame*/) override {
+ }
+ void SendRetireConnectionId(uint64_t /*sequence_number*/) override {}
+ void OnServerConnectionIdIssued(
+ const QuicConnectionId& /*server_connection_id*/) override {}
+ void OnServerConnectionIdRetired(
+ const QuicConnectionId& /*server_connection_id*/) override {}
+ bool AllowSelfAddressChange() const override;
+ HandshakeState GetHandshakeState() const override;
+ bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& /*frame*/) override {
+ return true;
+ }
+ bool OnStreamsBlockedFrame(
+ const QuicStreamsBlockedFrame& /*frame*/) override {
+ return true;
+ }
+ void OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) override {}
+ void OnPacketDecrypted(EncryptionLevel /*level*/) override {}
+ void OnOneRttPacketAcknowledged() override {}
+ void OnHandshakePacketSent() override {}
+ void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
+ std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
+ override {
+ return nullptr;
+ }
+ std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
+ return nullptr;
+ }
+ void BeforeConnectionCloseSent() override {}
+ bool ValidateToken(absl::string_view /*token*/) override { return true; }
+ bool MaybeSendAddressToken() override { return false; }
+ bool IsKnownServerAddress(
+ const QuicSocketAddress& /*address*/) const override {
+ return false;
+ }
+
+ // End QuicConnectionVisitorInterface implementation.
+
+ // Begin SessionNotifierInterface methods:
+ bool OnFrameAcked(const QuicFrame& frame,
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) override;
+ void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {}
+ void OnFrameLost(const QuicFrame& frame) override;
+ bool RetransmitFrames(const QuicFrames& frames,
+ TransmissionType type) override;
+ bool IsFrameOutstanding(const QuicFrame& frame) const override;
+ bool HasUnackedCryptoData() const override;
+ bool HasUnackedStreamData() const override;
+ // End SessionNotifierInterface implementation.
+
+ private:
+ // The producer outputs the repetition of the same byte. That sequence is
+ // verified by the receiver.
+ class DataProducer : public QuicStreamFrameDataProducer {
+ public:
+ WriteStreamDataResult WriteStreamData(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ bool WriteCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ };
+
+ std::unique_ptr<QuicConnection> CreateConnection(
+ Simulator* simulator,
+ std::string name,
+ std::string peer_name,
+ Perspective perspective,
+ QuicConnectionId connection_id);
+
+ // Write stream data until |bytes_to_transfer_| is zero or the connection is
+ // write-blocked.
+ void WriteStreamData();
+
+ DataProducer producer_;
+
+ QuicByteCount bytes_to_transfer_;
+ QuicByteCount bytes_transferred_;
+
+ // Set to true if the endpoint receives stream data different from what it
+ // expects.
+ bool wrong_data_received_;
+
+ // Record of received offsets in the data stream.
+ QuicIntervalSet<QuicStreamOffset> offsets_received_;
+
+ std::unique_ptr<test::SimpleSessionNotifier> notifier_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_base.cc b/quiche/quic/test_tools/simulator/quic_endpoint_base.cc
new file mode 100644
index 0000000..ad8c662
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_base.cc
@@ -0,0 +1,224 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/quic_endpoint_base.h"
+
+#include <memory>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "quiche/quic/core/crypto/crypto_handshake_message.h"
+#include "quiche/quic/core/crypto/crypto_protocol.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/platform/api/quic_test_output.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+// Takes a SHA-1 hash of the name and converts it into five 32-bit integers.
+static std::vector<uint32_t> HashNameIntoFive32BitIntegers(std::string name) {
+ const std::string hash = test::Sha1Hash(name);
+
+ std::vector<uint32_t> output;
+ uint32_t current_number = 0;
+ for (size_t i = 0; i < hash.size(); i++) {
+ current_number = (current_number << 8) + hash[i];
+ if (i % 4 == 3) {
+ output.push_back(i);
+ current_number = 0;
+ }
+ }
+
+ return output;
+}
+
+QuicSocketAddress GetAddressFromName(std::string name) {
+ const std::vector<uint32_t> hash = HashNameIntoFive32BitIntegers(name);
+
+ // Generate a random port between 1025 and 65535.
+ const uint16_t port = 1025 + hash[0] % (65535 - 1025 + 1);
+
+ // Generate a random 10.x.x.x address, where x is between 1 and 254.
+ std::string ip_address{"\xa\0\0\0", 4};
+ for (size_t i = 1; i < 4; i++) {
+ ip_address[i] = 1 + hash[i] % 254;
+ }
+ QuicIpAddress host;
+ host.FromPackedString(ip_address.c_str(), ip_address.length());
+ return QuicSocketAddress(host, port);
+}
+
+QuicEndpointBase::QuicEndpointBase(Simulator* simulator,
+ std::string name,
+ std::string peer_name)
+ : Endpoint(simulator, name),
+ peer_name_(peer_name),
+ writer_(this),
+ nic_tx_queue_(simulator,
+ absl::StrCat(name, " (TX Queue)"),
+ kMaxOutgoingPacketSize * kTxQueueSize),
+ connection_(nullptr),
+ write_blocked_count_(0),
+ drop_next_packet_(false) {
+ nic_tx_queue_.set_listener_interface(this);
+}
+
+QuicEndpointBase::~QuicEndpointBase() {
+ if (trace_visitor_ != nullptr) {
+ const char* perspective_prefix =
+ connection_->perspective() == Perspective::IS_CLIENT ? "C" : "S";
+
+ std::string identifier = absl::StrCat(
+ perspective_prefix, connection_->connection_id().ToString());
+ QuicRecordTrace(identifier, trace_visitor_->trace()->SerializeAsString());
+ }
+}
+
+void QuicEndpointBase::DropNextIncomingPacket() {
+ drop_next_packet_ = true;
+}
+
+void QuicEndpointBase::RecordTrace() {
+ trace_visitor_ = std::make_unique<QuicTraceVisitor>(connection_.get());
+ connection_->set_debug_visitor(trace_visitor_.get());
+}
+
+void QuicEndpointBase::AcceptPacket(std::unique_ptr<Packet> packet) {
+ if (packet->destination != name_) {
+ return;
+ }
+ if (drop_next_packet_) {
+ drop_next_packet_ = false;
+ return;
+ }
+
+ QuicReceivedPacket received_packet(packet->contents.data(),
+ packet->contents.size(), clock_->Now());
+ connection_->ProcessUdpPacket(connection_->self_address(),
+ connection_->peer_address(), received_packet);
+}
+
+UnconstrainedPortInterface* QuicEndpointBase::GetRxPort() {
+ return this;
+}
+
+void QuicEndpointBase::SetTxPort(ConstrainedPortInterface* port) {
+ // Any egress done by the endpoint is actually handled by a queue on an NIC.
+ nic_tx_queue_.set_tx_port(port);
+}
+
+void QuicEndpointBase::OnPacketDequeued() {
+ if (writer_.IsWriteBlocked() &&
+ (nic_tx_queue_.capacity() - nic_tx_queue_.bytes_queued()) >=
+ kMaxOutgoingPacketSize) {
+ writer_.SetWritable();
+ connection_->OnCanWrite();
+ }
+}
+
+QuicEndpointBase::Writer::Writer(QuicEndpointBase* endpoint)
+ : endpoint_(endpoint), is_blocked_(false) {}
+
+QuicEndpointBase::Writer::~Writer() {}
+
+WriteResult QuicEndpointBase::Writer::WritePacket(
+ const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/,
+ PerPacketOptions* options) {
+ QUICHE_DCHECK(!IsWriteBlocked());
+ QUICHE_DCHECK(options == nullptr);
+ QUICHE_DCHECK(buf_len <= kMaxOutgoingPacketSize);
+
+ // Instead of losing a packet, become write-blocked when the egress queue is
+ // full.
+ if (endpoint_->nic_tx_queue_.packets_queued() > kTxQueueSize) {
+ is_blocked_ = true;
+ endpoint_->write_blocked_count_++;
+ return WriteResult(WRITE_STATUS_BLOCKED, 0);
+ }
+
+ auto packet = std::make_unique<Packet>();
+ packet->source = endpoint_->name();
+ packet->destination = endpoint_->peer_name_;
+ packet->tx_timestamp = endpoint_->clock_->Now();
+
+ packet->contents = std::string(buffer, buf_len);
+ packet->size = buf_len;
+
+ endpoint_->nic_tx_queue_.AcceptPacket(std::move(packet));
+
+ return WriteResult(WRITE_STATUS_OK, buf_len);
+}
+
+bool QuicEndpointBase::Writer::IsWriteBlocked() const {
+ return is_blocked_;
+}
+
+void QuicEndpointBase::Writer::SetWritable() {
+ is_blocked_ = false;
+}
+
+absl::optional<int> QuicEndpointBase::Writer::MessageTooBigErrorCode() const {
+ return absl::nullopt;
+}
+
+QuicByteCount QuicEndpointBase::Writer::GetMaxPacketSize(
+ const QuicSocketAddress& /*peer_address*/) const {
+ return kMaxOutgoingPacketSize;
+}
+
+bool QuicEndpointBase::Writer::SupportsReleaseTime() const {
+ return false;
+}
+
+bool QuicEndpointBase::Writer::IsBatchMode() const {
+ return false;
+}
+
+QuicPacketBuffer QuicEndpointBase::Writer::GetNextWriteLocation(
+ const QuicIpAddress& /*self_address*/,
+ const QuicSocketAddress& /*peer_address*/) {
+ return {nullptr, nullptr};
+}
+
+WriteResult QuicEndpointBase::Writer::Flush() {
+ return WriteResult(WRITE_STATUS_OK, 0);
+}
+
+QuicEndpointMultiplexer::QuicEndpointMultiplexer(
+ std::string name,
+ const std::vector<QuicEndpointBase*>& endpoints)
+ : Endpoint((*endpoints.begin())->simulator(), name) {
+ for (QuicEndpointBase* endpoint : endpoints) {
+ mapping_.insert(std::make_pair(endpoint->name(), endpoint));
+ }
+}
+
+QuicEndpointMultiplexer::~QuicEndpointMultiplexer() {}
+
+void QuicEndpointMultiplexer::AcceptPacket(std::unique_ptr<Packet> packet) {
+ auto key_value_pair_it = mapping_.find(packet->destination);
+ if (key_value_pair_it == mapping_.end()) {
+ return;
+ }
+
+ key_value_pair_it->second->GetRxPort()->AcceptPacket(std::move(packet));
+}
+UnconstrainedPortInterface* QuicEndpointMultiplexer::GetRxPort() {
+ return this;
+}
+void QuicEndpointMultiplexer::SetTxPort(ConstrainedPortInterface* port) {
+ for (auto& key_value_pair : mapping_) {
+ key_value_pair.second->SetTxPort(port);
+ }
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_base.h b/quiche/quic/test_tools/simulator/quic_endpoint_base.h
new file mode 100644
index 0000000..24a3c47
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_base.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_BASE_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_BASE_H_
+
+#include <memory>
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/core/crypto/null_decrypter.h"
+#include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_default_packet_writer.h"
+#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_stream_frame_data_producer.h"
+#include "quiche/quic/core/quic_trace_visitor.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/test_tools/simple_session_notifier.h"
+#include "quiche/quic/test_tools/simulator/link.h"
+#include "quiche/quic/test_tools/simulator/queue.h"
+
+namespace quic {
+namespace simulator {
+
+// Size of the TX queue used by the kernel/NIC. 1000 is the Linux
+// kernel default.
+const QuicByteCount kTxQueueSize = 1000;
+
+// Generate a random local network host-port tuple based on the name of the
+// endpoint.
+QuicSocketAddress GetAddressFromName(std::string name);
+
+// A QUIC connection endpoint. If the specific data transmitted does not matter
+// (e.g. for congestion control purposes), QuicEndpoint is the subclass that
+// transmits dummy data. If the actual semantics of the connection matter,
+// subclassing QuicEndpointBase is required.
+class QuicEndpointBase : public Endpoint,
+ public UnconstrainedPortInterface,
+ public Queue::ListenerInterface {
+ public:
+ // Does not create the connection; the subclass has to create connection by
+ // itself.
+ QuicEndpointBase(Simulator* simulator,
+ std::string name,
+ std::string peer_name);
+ ~QuicEndpointBase() override;
+
+ QuicConnection* connection() { return connection_.get(); }
+ size_t write_blocked_count() { return write_blocked_count_; }
+
+ // Drop the next packet upon receipt.
+ void DropNextIncomingPacket();
+
+ // UnconstrainedPortInterface method. Called whenever the endpoint receives a
+ // packet.
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+
+ // Enables logging of the connection trace at the end of the unit test.
+ void RecordTrace();
+
+ // Begin Endpoint implementation.
+ UnconstrainedPortInterface* GetRxPort() override;
+ void SetTxPort(ConstrainedPortInterface* port) override;
+ // End Endpoint implementation.
+
+ // Actor method.
+ void Act() override {}
+
+ // Queue::ListenerInterface method.
+ void OnPacketDequeued() override;
+
+ protected:
+ // A Writer object that writes into the |nic_tx_queue_|.
+ class Writer : public QuicPacketWriter {
+ public:
+ explicit Writer(QuicEndpointBase* endpoint);
+ ~Writer() override;
+
+ WriteResult WritePacket(const char* buffer,
+ size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options) override;
+ bool IsWriteBlocked() const override;
+ void SetWritable() override;
+ absl::optional<int> MessageTooBigErrorCode() const override;
+ QuicByteCount GetMaxPacketSize(
+ const QuicSocketAddress& peer_address) const override;
+ bool SupportsReleaseTime() const override;
+ bool IsBatchMode() const override;
+ QuicPacketBuffer GetNextWriteLocation(
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address) override;
+ WriteResult Flush() override;
+
+ private:
+ QuicEndpointBase* endpoint_;
+
+ bool is_blocked_;
+ };
+
+ // The producer outputs the repetition of the same byte. That sequence is
+ // verified by the receiver.
+ class DataProducer : public QuicStreamFrameDataProducer {
+ public:
+ WriteStreamDataResult WriteStreamData(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ bool WriteCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ };
+
+ std::string peer_name_;
+
+ Writer writer_;
+ // The queue for the outgoing packets. In reality, this might be either on
+ // the network card, or in the kernel, but for concreteness we assume it's on
+ // the network card.
+ Queue nic_tx_queue_;
+ // Created by the subclass.
+ std::unique_ptr<QuicConnection> connection_;
+
+ // Counts the number of times the writer became write-blocked.
+ size_t write_blocked_count_;
+
+ // If true, drop the next packet when receiving it.
+ bool drop_next_packet_;
+
+ std::unique_ptr<QuicTraceVisitor> trace_visitor_;
+};
+
+// Multiplexes multiple connections at the same host on the network.
+class QuicEndpointMultiplexer : public Endpoint,
+ public UnconstrainedPortInterface {
+ public:
+ QuicEndpointMultiplexer(std::string name,
+ const std::vector<QuicEndpointBase*>& endpoints);
+ ~QuicEndpointMultiplexer() override;
+
+ // Receives a packet and passes it to the specified endpoint if that endpoint
+ // is one of the endpoints being multiplexed, otherwise ignores the packet.
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+ UnconstrainedPortInterface* GetRxPort() override;
+
+ // Sets the egress port for all the endpoints being multiplexed.
+ void SetTxPort(ConstrainedPortInterface* port) override;
+
+ void Act() override {}
+
+ private:
+ absl::flat_hash_map<std::string, QuicEndpointBase*> mapping_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_BASE_H_
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_test.cc b/quiche/quic/test_tools/simulator/quic_endpoint_test.cc
new file mode 100644
index 0000000..6952684
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_test.cc
@@ -0,0 +1,208 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/quic_endpoint.h"
+
+#include <utility>
+
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_connection_peer.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simulator/simulator.h"
+#include "quiche/quic/test_tools/simulator/switch.h"
+
+using ::testing::_;
+using ::testing::NiceMock;
+using ::testing::Return;
+
+namespace quic {
+namespace simulator {
+
+const QuicBandwidth kDefaultBandwidth =
+ QuicBandwidth::FromKBitsPerSecond(10 * 1000);
+const QuicTime::Delta kDefaultPropagationDelay =
+ QuicTime::Delta::FromMilliseconds(20);
+const QuicByteCount kDefaultBdp = kDefaultBandwidth * kDefaultPropagationDelay;
+
+// A simple test harness where all hosts are connected to a switch with
+// identical links.
+class QuicEndpointTest : public QuicTest {
+ public:
+ QuicEndpointTest()
+ : simulator_(), switch_(&simulator_, "Switch", 8, kDefaultBdp * 2) {}
+
+ protected:
+ Simulator simulator_;
+ Switch switch_;
+
+ std::unique_ptr<SymmetricLink> Link(Endpoint* a, Endpoint* b) {
+ return std::make_unique<SymmetricLink>(a, b, kDefaultBandwidth,
+ kDefaultPropagationDelay);
+ }
+
+ std::unique_ptr<SymmetricLink> CustomLink(Endpoint* a,
+ Endpoint* b,
+ uint64_t extra_rtt_ms) {
+ return std::make_unique<SymmetricLink>(
+ a, b, kDefaultBandwidth,
+ kDefaultPropagationDelay +
+ QuicTime::Delta::FromMilliseconds(extra_rtt_ms));
+ }
+};
+
+// Test transmission from one host to another.
+TEST_F(QuicEndpointTest, OneWayTransmission) {
+ QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
+ Perspective::IS_CLIENT, test::TestConnectionId(42));
+ QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
+ Perspective::IS_SERVER, test::TestConnectionId(42));
+ auto link_a = Link(&endpoint_a, switch_.port(1));
+ auto link_b = Link(&endpoint_b, switch_.port(2));
+
+ // First transmit a small, packet-size chunk of data.
+ endpoint_a.AddBytesToTransfer(600);
+ QuicTime end_time =
+ simulator_.GetClock()->Now() + QuicTime::Delta::FromMilliseconds(1000);
+ simulator_.RunUntil(
+ [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
+
+ EXPECT_EQ(600u, endpoint_a.bytes_transferred());
+ ASSERT_EQ(600u, endpoint_b.bytes_received());
+ EXPECT_FALSE(endpoint_a.wrong_data_received());
+ EXPECT_FALSE(endpoint_b.wrong_data_received());
+
+ // After a small chunk succeeds, try to transfer 2 MiB.
+ endpoint_a.AddBytesToTransfer(2 * 1024 * 1024);
+ end_time = simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(5);
+ simulator_.RunUntil(
+ [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
+
+ const QuicByteCount total_bytes_transferred = 600 + 2 * 1024 * 1024;
+ EXPECT_EQ(total_bytes_transferred, endpoint_a.bytes_transferred());
+ EXPECT_EQ(total_bytes_transferred, endpoint_b.bytes_received());
+ EXPECT_EQ(0u, endpoint_a.write_blocked_count());
+ EXPECT_FALSE(endpoint_a.wrong_data_received());
+ EXPECT_FALSE(endpoint_b.wrong_data_received());
+}
+
+// Test the situation in which the writer becomes write-blocked.
+TEST_F(QuicEndpointTest, WriteBlocked) {
+ QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
+ Perspective::IS_CLIENT, test::TestConnectionId(42));
+ QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
+ Perspective::IS_SERVER, test::TestConnectionId(42));
+ auto link_a = Link(&endpoint_a, switch_.port(1));
+ auto link_b = Link(&endpoint_b, switch_.port(2));
+
+ // Will be owned by the sent packet manager.
+ auto* sender = new NiceMock<test::MockSendAlgorithm>();
+ EXPECT_CALL(*sender, CanSend(_)).WillRepeatedly(Return(true));
+ EXPECT_CALL(*sender, PacingRate(_))
+ .WillRepeatedly(Return(10 * kDefaultBandwidth));
+ EXPECT_CALL(*sender, BandwidthEstimate())
+ .WillRepeatedly(Return(10 * kDefaultBandwidth));
+ EXPECT_CALL(*sender, GetCongestionWindow())
+ .WillRepeatedly(Return(kMaxOutgoingPacketSize *
+ GetQuicFlag(FLAGS_quic_max_congestion_window)));
+ test::QuicConnectionPeer::SetSendAlgorithm(endpoint_a.connection(), sender);
+
+ // First transmit a small, packet-size chunk of data.
+ QuicByteCount bytes_to_transfer = 3 * 1024 * 1024;
+ endpoint_a.AddBytesToTransfer(bytes_to_transfer);
+ QuicTime end_time =
+ simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(30);
+ simulator_.RunUntil([this, &endpoint_b, bytes_to_transfer, end_time]() {
+ return endpoint_b.bytes_received() == bytes_to_transfer ||
+ simulator_.GetClock()->Now() >= end_time;
+ });
+
+ EXPECT_EQ(bytes_to_transfer, endpoint_a.bytes_transferred());
+ EXPECT_EQ(bytes_to_transfer, endpoint_b.bytes_received());
+ EXPECT_GT(endpoint_a.write_blocked_count(), 0u);
+ EXPECT_FALSE(endpoint_a.wrong_data_received());
+ EXPECT_FALSE(endpoint_b.wrong_data_received());
+}
+
+// Test transmission of 1 MiB of data between two hosts simultaneously in both
+// directions.
+TEST_F(QuicEndpointTest, TwoWayTransmission) {
+ QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
+ Perspective::IS_CLIENT, test::TestConnectionId(42));
+ QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
+ Perspective::IS_SERVER, test::TestConnectionId(42));
+ auto link_a = Link(&endpoint_a, switch_.port(1));
+ auto link_b = Link(&endpoint_b, switch_.port(2));
+
+ endpoint_a.RecordTrace();
+ endpoint_b.RecordTrace();
+
+ endpoint_a.AddBytesToTransfer(1024 * 1024);
+ endpoint_b.AddBytesToTransfer(1024 * 1024);
+ QuicTime end_time =
+ simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(5);
+ simulator_.RunUntil(
+ [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
+
+ EXPECT_EQ(1024u * 1024u, endpoint_a.bytes_transferred());
+ EXPECT_EQ(1024u * 1024u, endpoint_b.bytes_transferred());
+ EXPECT_EQ(1024u * 1024u, endpoint_a.bytes_received());
+ EXPECT_EQ(1024u * 1024u, endpoint_b.bytes_received());
+ EXPECT_FALSE(endpoint_a.wrong_data_received());
+ EXPECT_FALSE(endpoint_b.wrong_data_received());
+}
+
+// Simulate three hosts trying to send data to a fourth one simultaneously.
+TEST_F(QuicEndpointTest, Competition) {
+ auto endpoint_a = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint A", "Endpoint D (A)", Perspective::IS_CLIENT,
+ test::TestConnectionId(42));
+ auto endpoint_b = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint B", "Endpoint D (B)", Perspective::IS_CLIENT,
+ test::TestConnectionId(43));
+ auto endpoint_c = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint C", "Endpoint D (C)", Perspective::IS_CLIENT,
+ test::TestConnectionId(44));
+ auto endpoint_d_a = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint D (A)", "Endpoint A", Perspective::IS_SERVER,
+ test::TestConnectionId(42));
+ auto endpoint_d_b = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint D (B)", "Endpoint B", Perspective::IS_SERVER,
+ test::TestConnectionId(43));
+ auto endpoint_d_c = std::make_unique<QuicEndpoint>(
+ &simulator_, "Endpoint D (C)", "Endpoint C", Perspective::IS_SERVER,
+ test::TestConnectionId(44));
+ QuicEndpointMultiplexer endpoint_d(
+ "Endpoint D",
+ {endpoint_d_a.get(), endpoint_d_b.get(), endpoint_d_c.get()});
+
+ // Create links with slightly different RTTs in order to avoid pathological
+ // side-effects of packets entering the queue at the exactly same time.
+ auto link_a = CustomLink(endpoint_a.get(), switch_.port(1), 0);
+ auto link_b = CustomLink(endpoint_b.get(), switch_.port(2), 1);
+ auto link_c = CustomLink(endpoint_c.get(), switch_.port(3), 2);
+ auto link_d = Link(&endpoint_d, switch_.port(4));
+
+ endpoint_a->AddBytesToTransfer(2 * 1024 * 1024);
+ endpoint_b->AddBytesToTransfer(2 * 1024 * 1024);
+ endpoint_c->AddBytesToTransfer(2 * 1024 * 1024);
+ QuicTime end_time =
+ simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(12);
+ simulator_.RunUntil(
+ [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
+
+ for (QuicEndpoint* endpoint :
+ {endpoint_a.get(), endpoint_b.get(), endpoint_c.get()}) {
+ EXPECT_EQ(2u * 1024u * 1024u, endpoint->bytes_transferred());
+ EXPECT_GE(endpoint->connection()->GetStats().packets_lost, 0u);
+ }
+ for (QuicEndpoint* endpoint :
+ {endpoint_d_a.get(), endpoint_d_b.get(), endpoint_d_c.get()}) {
+ EXPECT_EQ(2u * 1024u * 1024u, endpoint->bytes_received());
+ EXPECT_FALSE(endpoint->wrong_data_received());
+ }
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/simulator.cc b/quiche/quic/test_tools/simulator/simulator.cc
new file mode 100644
index 0000000..2b3c5d5
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/simulator.cc
@@ -0,0 +1,170 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+#include "quiche/quic/core/crypto/quic_random.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+
+namespace quic {
+namespace simulator {
+
+Simulator::Simulator() : Simulator(nullptr) {}
+
+Simulator::Simulator(QuicRandom* random_generator)
+ : random_generator_(random_generator),
+ alarm_factory_(this, "Default Alarm Manager"),
+ run_for_should_stop_(false),
+ enable_random_delays_(false) {
+ run_for_alarm_.reset(
+ alarm_factory_.CreateAlarm(new RunForDelegate(&run_for_should_stop_)));
+}
+
+Simulator::~Simulator() {
+ // Ensure that Actor under run_for_alarm_ is removed before Simulator data
+ // structures are destructed.
+ run_for_alarm_.reset();
+}
+
+Simulator::Clock::Clock() : now_(kStartTime) {}
+
+QuicTime Simulator::Clock::ApproximateNow() const {
+ return now_;
+}
+
+QuicTime Simulator::Clock::Now() const {
+ return now_;
+}
+
+QuicWallTime Simulator::Clock::WallNow() const {
+ return QuicWallTime::FromUNIXMicroseconds(
+ (now_ - QuicTime::Zero()).ToMicroseconds());
+}
+
+void Simulator::AddActor(Actor* actor) {
+ auto emplace_times_result =
+ scheduled_times_.insert(std::make_pair(actor, QuicTime::Infinite()));
+ auto emplace_names_result = actor_names_.insert(actor->name());
+
+ // Ensure that the object was actually placed into the map.
+ QUICHE_DCHECK(emplace_times_result.second);
+ QUICHE_DCHECK(emplace_names_result.second);
+}
+
+void Simulator::RemoveActor(Actor* actor) {
+ auto scheduled_time_it = scheduled_times_.find(actor);
+ auto actor_names_it = actor_names_.find(actor->name());
+ QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
+ QUICHE_DCHECK(actor_names_it != actor_names_.end());
+
+ QuicTime scheduled_time = scheduled_time_it->second;
+ if (scheduled_time != QuicTime::Infinite()) {
+ Unschedule(actor);
+ }
+
+ scheduled_times_.erase(scheduled_time_it);
+ actor_names_.erase(actor_names_it);
+}
+
+void Simulator::Schedule(Actor* actor, QuicTime new_time) {
+ auto scheduled_time_it = scheduled_times_.find(actor);
+ QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
+ QuicTime scheduled_time = scheduled_time_it->second;
+
+ if (scheduled_time <= new_time) {
+ return;
+ }
+
+ if (scheduled_time != QuicTime::Infinite()) {
+ Unschedule(actor);
+ }
+
+ scheduled_time_it->second = new_time;
+ schedule_.insert(std::make_pair(new_time, actor));
+}
+
+void Simulator::Unschedule(Actor* actor) {
+ auto scheduled_time_it = scheduled_times_.find(actor);
+ QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
+ QuicTime scheduled_time = scheduled_time_it->second;
+
+ QUICHE_DCHECK(scheduled_time != QuicTime::Infinite());
+ auto range = schedule_.equal_range(scheduled_time);
+ for (auto it = range.first; it != range.second; ++it) {
+ if (it->second == actor) {
+ schedule_.erase(it);
+ scheduled_time_it->second = QuicTime::Infinite();
+ return;
+ }
+ }
+ QUICHE_DCHECK(false);
+}
+
+const QuicClock* Simulator::GetClock() const {
+ return &clock_;
+}
+
+QuicRandom* Simulator::GetRandomGenerator() {
+ if (random_generator_ == nullptr) {
+ random_generator_ = QuicRandom::GetInstance();
+ }
+
+ return random_generator_;
+}
+
+quiche::QuicheBufferAllocator* Simulator::GetStreamSendBufferAllocator() {
+ return &buffer_allocator_;
+}
+
+QuicAlarmFactory* Simulator::GetAlarmFactory() {
+ return &alarm_factory_;
+}
+
+Simulator::RunForDelegate::RunForDelegate(bool* run_for_should_stop)
+ : run_for_should_stop_(run_for_should_stop) {}
+
+void Simulator::RunForDelegate::OnAlarm() {
+ *run_for_should_stop_ = true;
+}
+
+void Simulator::RunFor(QuicTime::Delta time_span) {
+ QUICHE_DCHECK(!run_for_alarm_->IsSet());
+
+ // RunFor() ensures that the simulation stops at the exact time specified by
+ // scheduling an alarm at that point and using that alarm to abort the
+ // simulation. An alarm is necessary because otherwise it is possible that
+ // nothing is scheduled at |end_time|, so the simulation will either go
+ // further than requested or stop before reaching |end_time|.
+ const QuicTime end_time = clock_.Now() + time_span;
+ run_for_alarm_->Set(end_time);
+ run_for_should_stop_ = false;
+ bool simulation_result = RunUntil([this]() { return run_for_should_stop_; });
+
+ QUICHE_DCHECK(simulation_result);
+ QUICHE_DCHECK(clock_.Now() == end_time);
+}
+
+void Simulator::HandleNextScheduledActor() {
+ const auto current_event_it = schedule_.begin();
+ QuicTime event_time = current_event_it->first;
+ Actor* actor = current_event_it->second;
+ QUIC_DVLOG(3) << "At t = " << event_time.ToDebuggingValue() << ", calling "
+ << actor->name();
+
+ Unschedule(actor);
+
+ if (clock_.Now() > event_time) {
+ QUIC_BUG(quic_bug_10150_1)
+ << "Error: event registered by [" << actor->name()
+ << "] requires travelling back in time. Current time: "
+ << clock_.Now().ToDebuggingValue()
+ << ", scheduled time: " << event_time.ToDebuggingValue();
+ }
+ clock_.now_ = event_time;
+
+ actor->Act();
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/simulator.h b/quiche/quic/test_tools/simulator/simulator.h
new file mode 100644
index 0000000..0dabe4a
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/simulator.h
@@ -0,0 +1,167 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SIMULATOR_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SIMULATOR_H_
+
+#include <map>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/test_tools/simulator/actor.h"
+#include "quiche/quic/test_tools/simulator/alarm_factory.h"
+#include "quiche/common/simple_buffer_allocator.h"
+
+namespace quic {
+namespace simulator {
+
+// Simulator is responsible for scheduling actors in the simulation and
+// providing basic utility interfaces (clock, alarms, RNG and others).
+class Simulator : public QuicConnectionHelperInterface {
+ public:
+ Simulator();
+ explicit Simulator(QuicRandom* random_generator);
+ Simulator(const Simulator&) = delete;
+ Simulator& operator=(const Simulator&) = delete;
+ ~Simulator() override;
+
+ // Schedule the specified actor. This method will ensure that |actor| is
+ // called at |new_time| at latest. If Schedule() is called multiple times
+ // before the Actor is called, Act() is called exactly once, at the earliest
+ // time requested, and the Actor has to reschedule itself manually for the
+ // subsequent times if they are still necessary.
+ void Schedule(Actor* actor, QuicTime new_time);
+
+ // Remove the specified actor from the schedule.
+ void Unschedule(Actor* actor);
+
+ // Begin QuicConnectionHelperInterface implementation.
+ const QuicClock* GetClock() const override;
+ QuicRandom* GetRandomGenerator() override;
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
+ // End QuicConnectionHelperInterface implementation.
+
+ QuicAlarmFactory* GetAlarmFactory();
+
+ void set_random_generator(QuicRandom* random) { random_generator_ = random; }
+
+ bool enable_random_delays() const { return enable_random_delays_; }
+
+ // Run the simulation until either no actors are scheduled or
+ // |termination_predicate| returns true. Returns true if terminated due to
+ // predicate, and false otherwise.
+ template <class TerminationPredicate>
+ bool RunUntil(TerminationPredicate termination_predicate);
+
+ // Same as RunUntil, except this function also accepts a |deadline|, and will
+ // return false if the deadline is exceeded.
+ template <class TerminationPredicate>
+ bool RunUntilOrTimeout(TerminationPredicate termination_predicate,
+ QuicTime::Delta deadline);
+
+ // Runs the simulation for exactly the specified |time_span|.
+ void RunFor(QuicTime::Delta time_span);
+
+ private:
+ friend class Actor;
+
+ class Clock : public QuicClock {
+ public:
+ // Do not start at zero as certain code can treat zero as an invalid
+ // timestamp.
+ const QuicTime kStartTime =
+ QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(1);
+
+ Clock();
+
+ QuicTime ApproximateNow() const override;
+ QuicTime Now() const override;
+ QuicWallTime WallNow() const override;
+
+ QuicTime now_;
+ };
+
+ // The delegate used for RunFor().
+ class RunForDelegate : public QuicAlarm::DelegateWithoutContext {
+ public:
+ explicit RunForDelegate(bool* run_for_should_stop);
+ void OnAlarm() override;
+
+ private:
+ // Pointer to |run_for_should_stop_| in the parent simulator.
+ bool* run_for_should_stop_;
+ };
+
+ // Register an actor with the simulator. Invoked by Actor constructor.
+ void AddActor(Actor* actor);
+
+ // Unregister an actor with the simulator. Invoked by Actor destructor.
+ void RemoveActor(Actor* actor);
+
+ // Finds the next scheduled actor, advances time to the schedule time and
+ // notifies the actor.
+ void HandleNextScheduledActor();
+
+ Clock clock_;
+ QuicRandom* random_generator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
+ AlarmFactory alarm_factory_;
+
+ // Alarm for RunFor() method.
+ std::unique_ptr<QuicAlarm> run_for_alarm_;
+ // Flag used to stop simulations ran via RunFor().
+ bool run_for_should_stop_;
+
+ // Indicates whether the simulator should add random delays on the links in
+ // order to avoid synchronization issues.
+ bool enable_random_delays_;
+
+ // Schedule of when the actors will be executed via an Act() call. The
+ // schedule is subject to the following invariants:
+ // - An actor cannot be scheduled for a later time than it's currently in the
+ // schedule.
+ // - An actor is removed from schedule either immediately before Act() is
+ // called or by explicitly calling Unschedule().
+ // - Each Actor appears in the map at most once.
+ std::multimap<QuicTime, Actor*> schedule_;
+ // For each actor, maintain the time it is scheduled at. The value for
+ // unscheduled actors is QuicTime::Infinite().
+ absl::flat_hash_map<Actor*, QuicTime> scheduled_times_;
+ absl::flat_hash_set<std::string> actor_names_;
+};
+
+template <class TerminationPredicate>
+bool Simulator::RunUntil(TerminationPredicate termination_predicate) {
+ bool predicate_value = false;
+ while (true) {
+ predicate_value = termination_predicate();
+ if (predicate_value || schedule_.empty()) {
+ break;
+ }
+ HandleNextScheduledActor();
+ }
+ return predicate_value;
+}
+
+template <class TerminationPredicate>
+bool Simulator::RunUntilOrTimeout(TerminationPredicate termination_predicate,
+ QuicTime::Delta timeout) {
+ QuicTime end_time = clock_.Now() + timeout;
+ bool return_value = RunUntil([end_time, &termination_predicate, this]() {
+ return termination_predicate() || clock_.Now() >= end_time;
+ });
+
+ if (clock_.Now() >= end_time) {
+ return false;
+ }
+ return return_value;
+}
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SIMULATOR_H_
diff --git a/quiche/quic/test_tools/simulator/simulator_test.cc b/quiche/quic/test_tools/simulator/simulator_test.cc
new file mode 100644
index 0000000..76ce046
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/simulator_test.cc
@@ -0,0 +1,832 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/simulator.h"
+
+#include <utility>
+
+#include "absl/container/node_hash_map.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/quic/test_tools/simulator/alarm_factory.h"
+#include "quiche/quic/test_tools/simulator/link.h"
+#include "quiche/quic/test_tools/simulator/packet_filter.h"
+#include "quiche/quic/test_tools/simulator/queue.h"
+#include "quiche/quic/test_tools/simulator/switch.h"
+#include "quiche/quic/test_tools/simulator/traffic_policer.h"
+
+using testing::_;
+using testing::Return;
+using testing::StrictMock;
+
+namespace quic {
+namespace simulator {
+
+// A simple counter that increments its value by 1 every specified period.
+class Counter : public Actor {
+ public:
+ Counter(Simulator* simulator, std::string name, QuicTime::Delta period)
+ : Actor(simulator, name), value_(-1), period_(period) {
+ Schedule(clock_->Now());
+ }
+ ~Counter() override {}
+
+ inline int get_value() const { return value_; }
+
+ void Act() override {
+ ++value_;
+ QUIC_DVLOG(1) << name_ << " has value " << value_ << " at time "
+ << clock_->Now().ToDebuggingValue();
+ Schedule(clock_->Now() + period_);
+ }
+
+ private:
+ int value_;
+ QuicTime::Delta period_;
+};
+
+class SimulatorTest : public QuicTest {};
+
+// Test that the basic event handling works, and that Actors can be created and
+// destroyed mid-simulation.
+TEST_F(SimulatorTest, Counters) {
+ Simulator simulator;
+ for (int i = 0; i < 2; ++i) {
+ Counter fast_counter(&simulator, "fast_counter",
+ QuicTime::Delta::FromSeconds(3));
+ Counter slow_counter(&simulator, "slow_counter",
+ QuicTime::Delta::FromSeconds(10));
+
+ simulator.RunUntil(
+ [&slow_counter]() { return slow_counter.get_value() >= 10; });
+
+ EXPECT_EQ(10, slow_counter.get_value());
+ EXPECT_EQ(10 * 10 / 3, fast_counter.get_value());
+ }
+}
+
+// A port which counts the number of packets received on it, both total and
+// per-destination.
+class CounterPort : public UnconstrainedPortInterface {
+ public:
+ CounterPort() { Reset(); }
+ ~CounterPort() override {}
+
+ inline QuicByteCount bytes() const { return bytes_; }
+ inline QuicPacketCount packets() const { return packets_; }
+
+ void AcceptPacket(std::unique_ptr<Packet> packet) override {
+ bytes_ += packet->size;
+ packets_ += 1;
+
+ per_destination_packet_counter_[packet->destination] += 1;
+ }
+
+ void Reset() {
+ bytes_ = 0;
+ packets_ = 0;
+ per_destination_packet_counter_.clear();
+ }
+
+ QuicPacketCount CountPacketsForDestination(std::string destination) const {
+ auto result_it = per_destination_packet_counter_.find(destination);
+ if (result_it == per_destination_packet_counter_.cend()) {
+ return 0;
+ }
+ return result_it->second;
+ }
+
+ private:
+ QuicByteCount bytes_;
+ QuicPacketCount packets_;
+
+ absl::node_hash_map<std::string, QuicPacketCount>
+ per_destination_packet_counter_;
+};
+
+// Sends the packet to the specified destination at the uplink rate. Provides a
+// CounterPort as an Rx interface.
+class LinkSaturator : public Endpoint {
+ public:
+ LinkSaturator(Simulator* simulator,
+ std::string name,
+ QuicByteCount packet_size,
+ std::string destination)
+ : Endpoint(simulator, name),
+ packet_size_(packet_size),
+ destination_(std::move(destination)),
+ bytes_transmitted_(0),
+ packets_transmitted_(0) {
+ Schedule(clock_->Now());
+ }
+
+ void Act() override {
+ if (tx_port_->TimeUntilAvailable().IsZero()) {
+ auto packet = std::make_unique<Packet>();
+ packet->source = name_;
+ packet->destination = destination_;
+ packet->tx_timestamp = clock_->Now();
+ packet->size = packet_size_;
+
+ tx_port_->AcceptPacket(std::move(packet));
+
+ bytes_transmitted_ += packet_size_;
+ packets_transmitted_ += 1;
+ }
+
+ Schedule(clock_->Now() + tx_port_->TimeUntilAvailable());
+ }
+
+ UnconstrainedPortInterface* GetRxPort() override {
+ return static_cast<UnconstrainedPortInterface*>(&rx_port_);
+ }
+
+ void SetTxPort(ConstrainedPortInterface* port) override { tx_port_ = port; }
+
+ CounterPort* counter() { return &rx_port_; }
+
+ inline QuicByteCount bytes_transmitted() const { return bytes_transmitted_; }
+ inline QuicPacketCount packets_transmitted() const {
+ return packets_transmitted_;
+ }
+
+ void Pause() { Unschedule(); }
+ void Resume() { Schedule(clock_->Now()); }
+
+ private:
+ QuicByteCount packet_size_;
+ std::string destination_;
+
+ ConstrainedPortInterface* tx_port_;
+ CounterPort rx_port_;
+
+ QuicByteCount bytes_transmitted_;
+ QuicPacketCount packets_transmitted_;
+};
+
+// Saturate a symmetric link and verify that the number of packets sent and
+// received is correct.
+TEST_F(SimulatorTest, DirectLinkSaturation) {
+ Simulator simulator;
+ LinkSaturator saturator_a(&simulator, "Saturator A", 1000, "Saturator B");
+ LinkSaturator saturator_b(&simulator, "Saturator B", 100, "Saturator A");
+ SymmetricLink link(&saturator_a, &saturator_b,
+ QuicBandwidth::FromKBytesPerSecond(1000),
+ QuicTime::Delta::FromMilliseconds(100) +
+ QuicTime::Delta::FromMicroseconds(1));
+
+ const QuicTime start_time = simulator.GetClock()->Now();
+ const QuicTime after_first_50_ms =
+ start_time + QuicTime::Delta::FromMilliseconds(50);
+ simulator.RunUntil([&simulator, after_first_50_ms]() {
+ return simulator.GetClock()->Now() >= after_first_50_ms;
+ });
+ EXPECT_LE(1000u * 50u, saturator_a.bytes_transmitted());
+ EXPECT_GE(1000u * 51u, saturator_a.bytes_transmitted());
+ EXPECT_LE(1000u * 50u, saturator_b.bytes_transmitted());
+ EXPECT_GE(1000u * 51u, saturator_b.bytes_transmitted());
+ EXPECT_LE(50u, saturator_a.packets_transmitted());
+ EXPECT_GE(51u, saturator_a.packets_transmitted());
+ EXPECT_LE(500u, saturator_b.packets_transmitted());
+ EXPECT_GE(501u, saturator_b.packets_transmitted());
+ EXPECT_EQ(0u, saturator_a.counter()->bytes());
+ EXPECT_EQ(0u, saturator_b.counter()->bytes());
+
+ simulator.RunUntil([&saturator_a, &saturator_b]() {
+ if (saturator_a.counter()->packets() > 1000 ||
+ saturator_b.counter()->packets() > 100) {
+ ADD_FAILURE() << "The simulation did not arrive at the expected "
+ "termination contidition. Saturator A counter: "
+ << saturator_a.counter()->packets()
+ << ", saturator B counter: "
+ << saturator_b.counter()->packets();
+ return true;
+ }
+
+ return saturator_a.counter()->packets() == 1000 &&
+ saturator_b.counter()->packets() == 100;
+ });
+ EXPECT_EQ(201u, saturator_a.packets_transmitted());
+ EXPECT_EQ(2001u, saturator_b.packets_transmitted());
+ EXPECT_EQ(201u * 1000, saturator_a.bytes_transmitted());
+ EXPECT_EQ(2001u * 100, saturator_b.bytes_transmitted());
+
+ EXPECT_EQ(1000u,
+ saturator_a.counter()->CountPacketsForDestination("Saturator A"));
+ EXPECT_EQ(100u,
+ saturator_b.counter()->CountPacketsForDestination("Saturator B"));
+ EXPECT_EQ(0u,
+ saturator_a.counter()->CountPacketsForDestination("Saturator B"));
+ EXPECT_EQ(0u,
+ saturator_b.counter()->CountPacketsForDestination("Saturator A"));
+
+ const QuicTime end_time = simulator.GetClock()->Now();
+ const QuicBandwidth observed_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
+ saturator_a.bytes_transmitted(), end_time - start_time);
+ EXPECT_APPROX_EQ(link.bandwidth(), observed_bandwidth, 0.01f);
+}
+
+// Accepts packets and stores them internally.
+class PacketAcceptor : public ConstrainedPortInterface {
+ public:
+ void AcceptPacket(std::unique_ptr<Packet> packet) override {
+ packets_.emplace_back(std::move(packet));
+ }
+
+ QuicTime::Delta TimeUntilAvailable() override {
+ return QuicTime::Delta::Zero();
+ }
+
+ std::vector<std::unique_ptr<Packet>>* packets() { return &packets_; }
+
+ private:
+ std::vector<std::unique_ptr<Packet>> packets_;
+};
+
+// Ensure the queue behaves correctly with accepting packets.
+TEST_F(SimulatorTest, Queue) {
+ Simulator simulator;
+ Queue queue(&simulator, "Queue", 1000);
+ PacketAcceptor acceptor;
+ queue.set_tx_port(&acceptor);
+
+ EXPECT_EQ(0u, queue.bytes_queued());
+ EXPECT_EQ(0u, queue.packets_queued());
+ EXPECT_EQ(0u, acceptor.packets()->size());
+
+ auto first_packet = std::make_unique<Packet>();
+ first_packet->size = 600;
+ queue.AcceptPacket(std::move(first_packet));
+ EXPECT_EQ(600u, queue.bytes_queued());
+ EXPECT_EQ(1u, queue.packets_queued());
+ EXPECT_EQ(0u, acceptor.packets()->size());
+
+ // The second packet does not fit and is dropped.
+ auto second_packet = std::make_unique<Packet>();
+ second_packet->size = 500;
+ queue.AcceptPacket(std::move(second_packet));
+ EXPECT_EQ(600u, queue.bytes_queued());
+ EXPECT_EQ(1u, queue.packets_queued());
+ EXPECT_EQ(0u, acceptor.packets()->size());
+
+ auto third_packet = std::make_unique<Packet>();
+ third_packet->size = 400;
+ queue.AcceptPacket(std::move(third_packet));
+ EXPECT_EQ(1000u, queue.bytes_queued());
+ EXPECT_EQ(2u, queue.packets_queued());
+ EXPECT_EQ(0u, acceptor.packets()->size());
+
+ // Run until there is nothing scheduled, so that the queue can deplete.
+ simulator.RunUntil([]() { return false; });
+ EXPECT_EQ(0u, queue.bytes_queued());
+ EXPECT_EQ(0u, queue.packets_queued());
+ ASSERT_EQ(2u, acceptor.packets()->size());
+ EXPECT_EQ(600u, acceptor.packets()->at(0)->size);
+ EXPECT_EQ(400u, acceptor.packets()->at(1)->size);
+}
+
+// Simulate a situation where the bottleneck link is 10 times slower than the
+// uplink, and they are separated by a queue.
+TEST_F(SimulatorTest, QueueBottleneck) {
+ const QuicBandwidth local_bandwidth =
+ QuicBandwidth::FromKBytesPerSecond(1000);
+ const QuicBandwidth bottleneck_bandwidth = 0.1f * local_bandwidth;
+ const QuicTime::Delta local_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(1);
+ const QuicTime::Delta bottleneck_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(20);
+ const QuicByteCount bdp =
+ bottleneck_bandwidth *
+ (local_propagation_delay + bottleneck_propagation_delay);
+
+ Simulator simulator;
+ LinkSaturator saturator(&simulator, "Saturator", 1000, "Counter");
+ ASSERT_GE(bdp, 1000u);
+ Queue queue(&simulator, "Queue", bdp);
+ CounterPort counter;
+
+ OneWayLink local_link(&simulator, "Local link", &queue, local_bandwidth,
+ local_propagation_delay);
+ OneWayLink bottleneck_link(&simulator, "Bottleneck link", &counter,
+ bottleneck_bandwidth,
+ bottleneck_propagation_delay);
+ saturator.SetTxPort(&local_link);
+ queue.set_tx_port(&bottleneck_link);
+
+ static const QuicPacketCount packets_received = 1000;
+ simulator.RunUntil(
+ [&counter]() { return counter.packets() == packets_received; });
+ const double loss_ratio = 1 - static_cast<double>(packets_received) /
+ saturator.packets_transmitted();
+ EXPECT_NEAR(loss_ratio, 0.9, 0.001);
+}
+
+// Verify that the queue of exactly one packet allows the transmission to
+// actually go through.
+TEST_F(SimulatorTest, OnePacketQueue) {
+ const QuicBandwidth local_bandwidth =
+ QuicBandwidth::FromKBytesPerSecond(1000);
+ const QuicBandwidth bottleneck_bandwidth = 0.1f * local_bandwidth;
+ const QuicTime::Delta local_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(1);
+ const QuicTime::Delta bottleneck_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(20);
+
+ Simulator simulator;
+ LinkSaturator saturator(&simulator, "Saturator", 1000, "Counter");
+ Queue queue(&simulator, "Queue", 1000);
+ CounterPort counter;
+
+ OneWayLink local_link(&simulator, "Local link", &queue, local_bandwidth,
+ local_propagation_delay);
+ OneWayLink bottleneck_link(&simulator, "Bottleneck link", &counter,
+ bottleneck_bandwidth,
+ bottleneck_propagation_delay);
+ saturator.SetTxPort(&local_link);
+ queue.set_tx_port(&bottleneck_link);
+
+ static const QuicPacketCount packets_received = 10;
+ // The deadline here is to prevent this tests from looping infinitely in case
+ // the packets never reach the receiver.
+ const QuicTime deadline =
+ simulator.GetClock()->Now() + QuicTime::Delta::FromSeconds(10);
+ simulator.RunUntil([&simulator, &counter, deadline]() {
+ return counter.packets() == packets_received ||
+ simulator.GetClock()->Now() > deadline;
+ });
+ ASSERT_EQ(packets_received, counter.packets());
+}
+
+// Simulate a network where three endpoints are connected to a switch and they
+// are sending traffic in circle (1 -> 2, 2 -> 3, 3 -> 1).
+TEST_F(SimulatorTest, SwitchedNetwork) {
+ const QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(10000);
+ const QuicTime::Delta base_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(50);
+
+ Simulator simulator;
+ LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
+ LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 3");
+ LinkSaturator saturator3(&simulator, "Saturator 3", 1000, "Saturator 1");
+ Switch network_switch(&simulator, "Switch", 8,
+ bandwidth * base_propagation_delay * 10);
+
+ // For determinicity, make it so that the first packet will arrive from
+ // Saturator 1, then from Saturator 2, and then from Saturator 3.
+ SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
+ base_propagation_delay);
+ SymmetricLink link2(&saturator2, network_switch.port(2), bandwidth,
+ base_propagation_delay * 2);
+ SymmetricLink link3(&saturator3, network_switch.port(3), bandwidth,
+ base_propagation_delay * 3);
+
+ const QuicTime start_time = simulator.GetClock()->Now();
+ static const QuicPacketCount bytes_received = 64 * 1000;
+ simulator.RunUntil([&saturator1]() {
+ return saturator1.counter()->bytes() >= bytes_received;
+ });
+ const QuicTime end_time = simulator.GetClock()->Now();
+
+ const QuicBandwidth observed_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
+ bytes_received, end_time - start_time);
+ const double bandwidth_ratio =
+ static_cast<double>(observed_bandwidth.ToBitsPerSecond()) /
+ bandwidth.ToBitsPerSecond();
+ EXPECT_NEAR(1, bandwidth_ratio, 0.1);
+
+ const double normalized_received_packets_for_saturator_2 =
+ static_cast<double>(saturator2.counter()->packets()) /
+ saturator1.counter()->packets();
+ const double normalized_received_packets_for_saturator_3 =
+ static_cast<double>(saturator3.counter()->packets()) /
+ saturator1.counter()->packets();
+ EXPECT_NEAR(1, normalized_received_packets_for_saturator_2, 0.1);
+ EXPECT_NEAR(1, normalized_received_packets_for_saturator_3, 0.1);
+
+ // Since Saturator 1 has its packet arrive first into the switch, switch will
+ // always know how to route traffic to it.
+ EXPECT_EQ(0u,
+ saturator2.counter()->CountPacketsForDestination("Saturator 1"));
+ EXPECT_EQ(0u,
+ saturator3.counter()->CountPacketsForDestination("Saturator 1"));
+
+ // Packets from the other saturators will be broadcast at least once.
+ EXPECT_EQ(1u,
+ saturator1.counter()->CountPacketsForDestination("Saturator 2"));
+ EXPECT_EQ(1u,
+ saturator3.counter()->CountPacketsForDestination("Saturator 2"));
+ EXPECT_EQ(1u,
+ saturator1.counter()->CountPacketsForDestination("Saturator 3"));
+ EXPECT_EQ(1u,
+ saturator2.counter()->CountPacketsForDestination("Saturator 3"));
+}
+
+// Toggle an alarm on and off at the specified interval. Assumes that alarm is
+// initially set and unsets it almost immediately after the object is
+// instantiated.
+class AlarmToggler : public Actor {
+ public:
+ AlarmToggler(Simulator* simulator,
+ std::string name,
+ QuicAlarm* alarm,
+ QuicTime::Delta interval)
+ : Actor(simulator, name),
+ alarm_(alarm),
+ interval_(interval),
+ deadline_(alarm->deadline()),
+ times_set_(0),
+ times_cancelled_(0) {
+ EXPECT_TRUE(alarm->IsSet());
+ EXPECT_GE(alarm->deadline(), clock_->Now());
+ Schedule(clock_->Now());
+ }
+
+ void Act() override {
+ if (deadline_ <= clock_->Now()) {
+ return;
+ }
+
+ if (alarm_->IsSet()) {
+ alarm_->Cancel();
+ times_cancelled_++;
+ } else {
+ alarm_->Set(deadline_);
+ times_set_++;
+ }
+
+ Schedule(clock_->Now() + interval_);
+ }
+
+ inline int times_set() { return times_set_; }
+ inline int times_cancelled() { return times_cancelled_; }
+
+ private:
+ QuicAlarm* alarm_;
+ QuicTime::Delta interval_;
+ QuicTime deadline_;
+
+ // Counts the number of times the alarm was set.
+ int times_set_;
+ // Counts the number of times the alarm was cancelled.
+ int times_cancelled_;
+};
+
+// Counts the number of times an alarm has fired.
+class CounterDelegate : public QuicAlarm::DelegateWithoutContext {
+ public:
+ explicit CounterDelegate(size_t* counter) : counter_(counter) {}
+
+ void OnAlarm() override { *counter_ += 1; }
+
+ private:
+ size_t* counter_;
+};
+
+// Verifies that the alarms work correctly, even when they are repeatedly
+// toggled.
+TEST_F(SimulatorTest, Alarms) {
+ Simulator simulator;
+ QuicAlarmFactory* alarm_factory = simulator.GetAlarmFactory();
+
+ size_t fast_alarm_counter = 0;
+ size_t slow_alarm_counter = 0;
+ std::unique_ptr<QuicAlarm> alarm_fast(
+ alarm_factory->CreateAlarm(new CounterDelegate(&fast_alarm_counter)));
+ std::unique_ptr<QuicAlarm> alarm_slow(
+ alarm_factory->CreateAlarm(new CounterDelegate(&slow_alarm_counter)));
+
+ const QuicTime start_time = simulator.GetClock()->Now();
+ alarm_fast->Set(start_time + QuicTime::Delta::FromMilliseconds(100));
+ alarm_slow->Set(start_time + QuicTime::Delta::FromMilliseconds(750));
+ AlarmToggler toggler(&simulator, "Toggler", alarm_slow.get(),
+ QuicTime::Delta::FromMilliseconds(100));
+
+ const QuicTime end_time =
+ start_time + QuicTime::Delta::FromMilliseconds(1000);
+ EXPECT_FALSE(simulator.RunUntil([&simulator, end_time]() {
+ return simulator.GetClock()->Now() >= end_time;
+ }));
+ EXPECT_EQ(1u, slow_alarm_counter);
+ EXPECT_EQ(1u, fast_alarm_counter);
+
+ EXPECT_EQ(4, toggler.times_set());
+ EXPECT_EQ(4, toggler.times_cancelled());
+}
+
+// Verifies that a cancelled alarm is never fired.
+TEST_F(SimulatorTest, AlarmCancelling) {
+ Simulator simulator;
+ QuicAlarmFactory* alarm_factory = simulator.GetAlarmFactory();
+
+ size_t alarm_counter = 0;
+ std::unique_ptr<QuicAlarm> alarm(
+ alarm_factory->CreateAlarm(new CounterDelegate(&alarm_counter)));
+
+ const QuicTime start_time = simulator.GetClock()->Now();
+ const QuicTime alarm_at = start_time + QuicTime::Delta::FromMilliseconds(300);
+ const QuicTime end_time = start_time + QuicTime::Delta::FromMilliseconds(400);
+
+ alarm->Set(alarm_at);
+ alarm->Cancel();
+ EXPECT_FALSE(alarm->IsSet());
+
+ EXPECT_FALSE(simulator.RunUntil([&simulator, end_time]() {
+ return simulator.GetClock()->Now() >= end_time;
+ }));
+
+ EXPECT_FALSE(alarm->IsSet());
+ EXPECT_EQ(0u, alarm_counter);
+}
+
+// Verifies that alarms can be scheduled into the past.
+TEST_F(SimulatorTest, AlarmInPast) {
+ Simulator simulator;
+ QuicAlarmFactory* alarm_factory = simulator.GetAlarmFactory();
+
+ size_t alarm_counter = 0;
+ std::unique_ptr<QuicAlarm> alarm(
+ alarm_factory->CreateAlarm(new CounterDelegate(&alarm_counter)));
+
+ const QuicTime start_time = simulator.GetClock()->Now();
+ simulator.RunFor(QuicTime::Delta::FromMilliseconds(400));
+
+ alarm->Set(start_time);
+ simulator.RunFor(QuicTime::Delta::FromMilliseconds(1));
+ EXPECT_FALSE(alarm->IsSet());
+ EXPECT_EQ(1u, alarm_counter);
+}
+
+// Tests Simulator::RunUntilOrTimeout() interface.
+TEST_F(SimulatorTest, RunUntilOrTimeout) {
+ Simulator simulator;
+ bool simulation_result;
+
+ // Count the number of seconds since the beginning of the simulation.
+ Counter counter(&simulator, "counter", QuicTime::Delta::FromSeconds(1));
+
+ // Ensure that the counter reaches the value of 10 given a 20 second deadline.
+ simulation_result = simulator.RunUntilOrTimeout(
+ [&counter]() { return counter.get_value() == 10; },
+ QuicTime::Delta::FromSeconds(20));
+ ASSERT_TRUE(simulation_result);
+
+ // Ensure that the counter will not reach the value of 100 given that the
+ // starting value is 10 and the deadline is 20 seconds.
+ simulation_result = simulator.RunUntilOrTimeout(
+ [&counter]() { return counter.get_value() == 100; },
+ QuicTime::Delta::FromSeconds(20));
+ ASSERT_FALSE(simulation_result);
+}
+
+// Tests Simulator::RunFor() interface.
+TEST_F(SimulatorTest, RunFor) {
+ Simulator simulator;
+
+ Counter counter(&simulator, "counter", QuicTime::Delta::FromSeconds(3));
+
+ simulator.RunFor(QuicTime::Delta::FromSeconds(100));
+
+ EXPECT_EQ(33, counter.get_value());
+}
+
+class MockPacketFilter : public PacketFilter {
+ public:
+ MockPacketFilter(Simulator* simulator, std::string name, Endpoint* endpoint)
+ : PacketFilter(simulator, name, endpoint) {}
+ MOCK_METHOD(bool, FilterPacket, (const Packet&), (override));
+};
+
+// Set up two trivial packet filters, one allowing any packets, and one dropping
+// all of them.
+TEST_F(SimulatorTest, PacketFilter) {
+ const QuicBandwidth bandwidth =
+ QuicBandwidth::FromBytesPerSecond(1024 * 1024);
+ const QuicTime::Delta base_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(5);
+
+ Simulator simulator;
+ LinkSaturator saturator_a(&simulator, "Saturator A", 1000, "Saturator B");
+ LinkSaturator saturator_b(&simulator, "Saturator B", 1000, "Saturator A");
+
+ // Attach packets to the switch to create a delay between the point at which
+ // the packet is generated and the point at which it is filtered. Note that
+ // if the saturators were connected directly, the link would be always
+ // available for the endpoint which has all of its packets dropped, resulting
+ // in saturator looping infinitely.
+ Switch network_switch(&simulator, "Switch", 8,
+ bandwidth * base_propagation_delay * 10);
+ StrictMock<MockPacketFilter> a_to_b_filter(&simulator, "A -> B filter",
+ network_switch.port(1));
+ StrictMock<MockPacketFilter> b_to_a_filter(&simulator, "B -> A filter",
+ network_switch.port(2));
+ SymmetricLink link_a(&a_to_b_filter, &saturator_b, bandwidth,
+ base_propagation_delay);
+ SymmetricLink link_b(&b_to_a_filter, &saturator_a, bandwidth,
+ base_propagation_delay);
+
+ // Allow packets from A to B, but not from B to A.
+ EXPECT_CALL(a_to_b_filter, FilterPacket(_)).WillRepeatedly(Return(true));
+ EXPECT_CALL(b_to_a_filter, FilterPacket(_)).WillRepeatedly(Return(false));
+
+ // Run the simulation for a while, and expect that only B will receive any
+ // packets.
+ simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+ EXPECT_GE(saturator_b.counter()->packets(), 1u);
+ EXPECT_EQ(saturator_a.counter()->packets(), 0u);
+}
+
+// Set up a traffic policer in one direction that throttles at 25% of link
+// bandwidth, and put two link saturators at each endpoint.
+TEST_F(SimulatorTest, TrafficPolicer) {
+ const QuicBandwidth bandwidth =
+ QuicBandwidth::FromBytesPerSecond(1024 * 1024);
+ const QuicTime::Delta base_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(5);
+ const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
+
+ Simulator simulator;
+ LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
+ LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
+ Switch network_switch(&simulator, "Switch", 8,
+ bandwidth * base_propagation_delay * 10);
+
+ static const QuicByteCount initial_burst = 1000 * 10;
+ static const QuicByteCount max_bucket_size = 1000 * 100;
+ static const QuicBandwidth target_bandwidth = bandwidth * 0.25;
+ TrafficPolicer policer(&simulator, "Policer", initial_burst, max_bucket_size,
+ target_bandwidth, network_switch.port(2));
+
+ SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
+ base_propagation_delay);
+ SymmetricLink link2(&saturator2, &policer, bandwidth, base_propagation_delay);
+
+ // Ensure the initial burst passes without being dropped at all.
+ bool simulator_result = simulator.RunUntilOrTimeout(
+ [&saturator1]() {
+ return saturator1.bytes_transmitted() == initial_burst;
+ },
+ timeout);
+ ASSERT_TRUE(simulator_result);
+ saturator1.Pause();
+ simulator_result = simulator.RunUntilOrTimeout(
+ [&saturator2]() {
+ return saturator2.counter()->bytes() == initial_burst;
+ },
+ timeout);
+ ASSERT_TRUE(simulator_result);
+ saturator1.Resume();
+
+ // Run for some time so that the initial burst is not visible.
+ const QuicTime::Delta simulation_time = QuicTime::Delta::FromSeconds(10);
+ simulator.RunFor(simulation_time);
+
+ // Ensure we've transmitted the amount of data we expected.
+ for (auto* saturator : {&saturator1, &saturator2}) {
+ EXPECT_APPROX_EQ(bandwidth * simulation_time,
+ saturator->bytes_transmitted(), 0.01f);
+ }
+
+ // Check that only one direction is throttled.
+ EXPECT_APPROX_EQ(saturator1.bytes_transmitted() / 4,
+ saturator2.counter()->bytes(), 0.1f);
+ EXPECT_APPROX_EQ(saturator2.bytes_transmitted(),
+ saturator1.counter()->bytes(), 0.1f);
+}
+
+// Ensure that a larger burst is allowed when the policed saturator exits
+// quiescence.
+TEST_F(SimulatorTest, TrafficPolicerBurst) {
+ const QuicBandwidth bandwidth =
+ QuicBandwidth::FromBytesPerSecond(1024 * 1024);
+ const QuicTime::Delta base_propagation_delay =
+ QuicTime::Delta::FromMilliseconds(5);
+ const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
+
+ Simulator simulator;
+ LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
+ LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
+ Switch network_switch(&simulator, "Switch", 8,
+ bandwidth * base_propagation_delay * 10);
+
+ const QuicByteCount initial_burst = 1000 * 10;
+ const QuicByteCount max_bucket_size = 1000 * 100;
+ const QuicBandwidth target_bandwidth = bandwidth * 0.25;
+ TrafficPolicer policer(&simulator, "Policer", initial_burst, max_bucket_size,
+ target_bandwidth, network_switch.port(2));
+
+ SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
+ base_propagation_delay);
+ SymmetricLink link2(&saturator2, &policer, bandwidth, base_propagation_delay);
+
+ // Ensure at least one packet is sent on each side.
+ bool simulator_result = simulator.RunUntilOrTimeout(
+ [&saturator1, &saturator2]() {
+ return saturator1.packets_transmitted() > 0 &&
+ saturator2.packets_transmitted() > 0;
+ },
+ timeout);
+ ASSERT_TRUE(simulator_result);
+
+ // Wait until the bucket fills up.
+ saturator1.Pause();
+ saturator2.Pause();
+ simulator.RunFor(1.5f * target_bandwidth.TransferTime(max_bucket_size));
+
+ // Send a burst.
+ saturator1.Resume();
+ simulator.RunFor(bandwidth.TransferTime(max_bucket_size));
+ saturator1.Pause();
+ simulator.RunFor(2 * base_propagation_delay);
+
+ // Expect the burst to pass without losses.
+ EXPECT_APPROX_EQ(saturator1.bytes_transmitted(),
+ saturator2.counter()->bytes(), 0.1f);
+
+ // Expect subsequent traffic to be policed.
+ saturator1.Resume();
+ simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+ EXPECT_APPROX_EQ(saturator1.bytes_transmitted() / 4,
+ saturator2.counter()->bytes(), 0.1f);
+}
+
+// Test that the packet aggregation support in queues work.
+TEST_F(SimulatorTest, PacketAggregation) {
+ // Model network where the delays are dominated by transfer delay.
+ const QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(1000);
+ const QuicTime::Delta base_propagation_delay =
+ QuicTime::Delta::FromMicroseconds(1);
+ const QuicByteCount aggregation_threshold = 1000;
+ const QuicTime::Delta aggregation_timeout = QuicTime::Delta::FromSeconds(30);
+
+ Simulator simulator;
+ LinkSaturator saturator1(&simulator, "Saturator 1", 10, "Saturator 2");
+ LinkSaturator saturator2(&simulator, "Saturator 2", 10, "Saturator 1");
+ Switch network_switch(&simulator, "Switch", 8, 10 * aggregation_threshold);
+
+ // Make links with asymmetric propagation delay so that Saturator 2 only
+ // receives packets addressed to it.
+ SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
+ base_propagation_delay);
+ SymmetricLink link2(&saturator2, network_switch.port(2), bandwidth,
+ 2 * base_propagation_delay);
+
+ // Enable aggregation in 1 -> 2 direction.
+ Queue* queue = network_switch.port_queue(2);
+ queue->EnableAggregation(aggregation_threshold, aggregation_timeout);
+
+ // Enable aggregation in 2 -> 1 direction in a way that all packets are larger
+ // than the threshold, so that aggregation is effectively a no-op.
+ network_switch.port_queue(1)->EnableAggregation(5, aggregation_timeout);
+
+ // Fill up the aggregation buffer up to 90% (900 bytes).
+ simulator.RunFor(0.9 * bandwidth.TransferTime(aggregation_threshold));
+ EXPECT_EQ(0u, saturator2.counter()->bytes());
+
+ // Stop sending, ensure that given a timespan much shorter than timeout, the
+ // packets remain in the queue.
+ saturator1.Pause();
+ saturator2.Pause();
+ simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+ EXPECT_EQ(0u, saturator2.counter()->bytes());
+ EXPECT_EQ(900u, queue->bytes_queued());
+
+ // Ensure that all packets have reached the saturator not affected by
+ // aggregation. Here, 10 extra bytes account for a misrouted packet in the
+ // beginning.
+ EXPECT_EQ(910u, saturator1.counter()->bytes());
+
+ // Send 500 more bytes. Since the aggregation threshold is 1000 bytes, and
+ // queue already has 900 bytes, 1000 bytes will be send and 400 will be in the
+ // queue.
+ saturator1.Resume();
+ simulator.RunFor(0.5 * bandwidth.TransferTime(aggregation_threshold));
+ saturator1.Pause();
+ simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+ EXPECT_EQ(1000u, saturator2.counter()->bytes());
+ EXPECT_EQ(400u, queue->bytes_queued());
+
+ // Actually time out, and cause all of the data to be received.
+ simulator.RunFor(aggregation_timeout);
+ EXPECT_EQ(1400u, saturator2.counter()->bytes());
+ EXPECT_EQ(0u, queue->bytes_queued());
+
+ // Run saturator for a longer time, to ensure that the logic to cancel and
+ // reset alarms works correctly.
+ saturator1.Resume();
+ simulator.RunFor(5.5 * bandwidth.TransferTime(aggregation_threshold));
+ saturator1.Pause();
+ simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+ EXPECT_EQ(6400u, saturator2.counter()->bytes());
+ EXPECT_EQ(500u, queue->bytes_queued());
+
+ // Time out again.
+ simulator.RunFor(aggregation_timeout);
+ EXPECT_EQ(6900u, saturator2.counter()->bytes());
+ EXPECT_EQ(0u, queue->bytes_queued());
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/switch.cc b/quiche/quic/test_tools/simulator/switch.cc
new file mode 100644
index 0000000..f897ccb
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/switch.cc
@@ -0,0 +1,83 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cinttypes>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "quiche/quic/test_tools/simulator/switch.h"
+
+namespace quic {
+namespace simulator {
+
+Switch::Switch(Simulator* simulator,
+ std::string name,
+ SwitchPortNumber port_count,
+ QuicByteCount queue_capacity) {
+ for (size_t port_number = 1; port_number <= port_count; port_number++) {
+ ports_.emplace_back(simulator,
+ absl::StrCat(name, " (port ", port_number, ")"), this,
+ port_number, queue_capacity);
+ }
+}
+
+Switch::~Switch() {}
+
+Switch::Port::Port(Simulator* simulator,
+ std::string name,
+ Switch* parent,
+ SwitchPortNumber port_number,
+ QuicByteCount queue_capacity)
+ : Endpoint(simulator, name),
+ parent_(parent),
+ port_number_(port_number),
+ connected_(false),
+ queue_(simulator, absl::StrCat(name, " (queue)"), queue_capacity) {}
+
+void Switch::Port::AcceptPacket(std::unique_ptr<Packet> packet) {
+ parent_->DispatchPacket(port_number_, std::move(packet));
+}
+
+void Switch::Port::EnqueuePacket(std::unique_ptr<Packet> packet) {
+ queue_.AcceptPacket(std::move(packet));
+}
+
+UnconstrainedPortInterface* Switch::Port::GetRxPort() {
+ return this;
+}
+
+void Switch::Port::SetTxPort(ConstrainedPortInterface* port) {
+ queue_.set_tx_port(port);
+ connected_ = true;
+}
+
+void Switch::Port::Act() {}
+
+void Switch::DispatchPacket(SwitchPortNumber port_number,
+ std::unique_ptr<Packet> packet) {
+ Port* source_port = &ports_[port_number - 1];
+ const auto source_mapping_it = switching_table_.find(packet->source);
+ if (source_mapping_it == switching_table_.end()) {
+ switching_table_.insert(std::make_pair(packet->source, source_port));
+ }
+
+ const auto destination_mapping_it =
+ switching_table_.find(packet->destination);
+ if (destination_mapping_it != switching_table_.end()) {
+ destination_mapping_it->second->EnqueuePacket(std::move(packet));
+ return;
+ }
+
+ // If no mapping is available yet, broadcast the packet to all ports
+ // different from the source.
+ for (Port& egress_port : ports_) {
+ if (!egress_port.connected()) {
+ continue;
+ }
+ egress_port.EnqueuePacket(std::make_unique<Packet>(*packet));
+ }
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/switch.h b/quiche/quic/test_tools/simulator/switch.h
new file mode 100644
index 0000000..df25367
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/switch.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SWITCH_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SWITCH_H_
+
+#include <deque>
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/platform/api/quic_containers.h"
+#include "quiche/quic/test_tools/simulator/queue.h"
+
+namespace quic {
+namespace simulator {
+
+using SwitchPortNumber = size_t;
+
+// Simulates a network switch with simple persistent learning scheme and queues
+// on every output port.
+class Switch {
+ public:
+ Switch(Simulator* simulator,
+ std::string name,
+ SwitchPortNumber port_count,
+ QuicByteCount queue_capacity);
+ Switch(const Switch&) = delete;
+ Switch& operator=(const Switch&) = delete;
+ ~Switch();
+
+ // Returns Endpoint associated with the port under number |port_number|. Just
+ // like on most real switches, port numbering starts with 1.
+ Endpoint* port(SwitchPortNumber port_number) {
+ QUICHE_DCHECK_NE(port_number, 0u);
+ return &ports_[port_number - 1];
+ }
+
+ Queue* port_queue(SwitchPortNumber port_number) {
+ return ports_[port_number - 1].queue();
+ }
+
+ private:
+ class Port : public Endpoint, public UnconstrainedPortInterface {
+ public:
+ Port(Simulator* simulator,
+ std::string name,
+ Switch* parent,
+ SwitchPortNumber port_number,
+ QuicByteCount queue_capacity);
+ Port(Port&&) = delete;
+ Port(const Port&) = delete;
+ Port& operator=(const Port&) = delete;
+ ~Port() override {}
+
+ // Accepts packet to be routed into the switch.
+ void AcceptPacket(std::unique_ptr<Packet> packet) override;
+ // Enqueue packet to be routed out of the switch.
+ void EnqueuePacket(std::unique_ptr<Packet> packet);
+
+ UnconstrainedPortInterface* GetRxPort() override;
+ void SetTxPort(ConstrainedPortInterface* port) override;
+
+ void Act() override;
+
+ bool connected() const { return connected_; }
+ Queue* queue() { return &queue_; }
+
+ private:
+ Switch* parent_;
+ SwitchPortNumber port_number_;
+ bool connected_;
+
+ Queue queue_;
+ };
+
+ // Sends the packet to the appropriate port, or to all ports if the
+ // appropriate port is not known.
+ void DispatchPacket(SwitchPortNumber port_number,
+ std::unique_ptr<Packet> packet);
+
+ // This cannot be a quiche::QuicheCircularDeque since pointers into this are
+ // assumed to be stable.
+ std::deque<Port> ports_;
+ absl::flat_hash_map<std::string, Port*> switching_table_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_SWITCH_H_
diff --git a/quiche/quic/test_tools/simulator/traffic_policer.cc b/quiche/quic/test_tools/simulator/traffic_policer.cc
new file mode 100644
index 0000000..8bd3a24
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/traffic_policer.cc
@@ -0,0 +1,60 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/simulator/traffic_policer.h"
+
+#include <algorithm>
+
+namespace quic {
+namespace simulator {
+
+TrafficPolicer::TrafficPolicer(Simulator* simulator,
+ std::string name,
+ QuicByteCount initial_bucket_size,
+ QuicByteCount max_bucket_size,
+ QuicBandwidth target_bandwidth,
+ Endpoint* input)
+ : PacketFilter(simulator, name, input),
+ initial_bucket_size_(initial_bucket_size),
+ max_bucket_size_(max_bucket_size),
+ target_bandwidth_(target_bandwidth),
+ last_refill_time_(clock_->Now()) {}
+
+TrafficPolicer::~TrafficPolicer() {}
+
+void TrafficPolicer::Refill() {
+ QuicTime::Delta time_passed = clock_->Now() - last_refill_time_;
+ QuicByteCount refill_size = time_passed * target_bandwidth_;
+
+ for (auto& bucket : token_buckets_) {
+ bucket.second = std::min(bucket.second + refill_size, max_bucket_size_);
+ }
+
+ last_refill_time_ = clock_->Now();
+}
+
+bool TrafficPolicer::FilterPacket(const Packet& packet) {
+ // Refill existing buckets.
+ Refill();
+
+ // Create a new bucket if one does not exist.
+ if (token_buckets_.count(packet.destination) == 0) {
+ token_buckets_.insert(
+ std::make_pair(packet.destination, initial_bucket_size_));
+ }
+
+ auto bucket = token_buckets_.find(packet.destination);
+ QUICHE_DCHECK(bucket != token_buckets_.end());
+
+ // Silently drop the packet on the floor if out of tokens
+ if (bucket->second < packet.size) {
+ return false;
+ }
+
+ bucket->second -= packet.size;
+ return true;
+}
+
+} // namespace simulator
+} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/traffic_policer.h b/quiche/quic/test_tools/simulator/traffic_policer.h
new file mode 100644
index 0000000..f8b889e
--- /dev/null
+++ b/quiche/quic/test_tools/simulator/traffic_policer.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_TRAFFIC_POLICER_H_
+#define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_TRAFFIC_POLICER_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/test_tools/simulator/packet_filter.h"
+#include "quiche/quic/test_tools/simulator/port.h"
+
+namespace quic {
+namespace simulator {
+
+// Traffic policer uses a token bucket to limit the bandwidth of the traffic
+// passing through. It wraps around an input port and exposes an output port.
+// Only the traffic from input to the output is policed, so in case when
+// bidirectional policing is desired, two policers have to be used. The flows
+// are hashed by the destination only.
+class TrafficPolicer : public PacketFilter {
+ public:
+ TrafficPolicer(Simulator* simulator,
+ std::string name,
+ QuicByteCount initial_bucket_size,
+ QuicByteCount max_bucket_size,
+ QuicBandwidth target_bandwidth,
+ Endpoint* input);
+ TrafficPolicer(const TrafficPolicer&) = delete;
+ TrafficPolicer& operator=(const TrafficPolicer&) = delete;
+ ~TrafficPolicer() override;
+
+ protected:
+ bool FilterPacket(const Packet& packet) override;
+
+ private:
+ // Refill the token buckets with all the tokens that have been granted since
+ // |last_refill_time_|.
+ void Refill();
+
+ QuicByteCount initial_bucket_size_;
+ QuicByteCount max_bucket_size_;
+ QuicBandwidth target_bandwidth_;
+
+ // The time at which the token buckets were last refilled.
+ QuicTime last_refill_time_;
+
+ // Maps each destination to the number of tokens it has left.
+ absl::flat_hash_map<std::string, QuicByteCount> token_buckets_;
+};
+
+} // namespace simulator
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_SIMULATOR_TRAFFIC_POLICER_H_
diff --git a/quiche/quic/test_tools/test_certificates.cc b/quiche/quic/test_tools/test_certificates.cc
new file mode 100644
index 0000000..67ef981
--- /dev/null
+++ b/quiche/quic/test_tools/test_certificates.cc
@@ -0,0 +1,734 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/test_certificates.h"
+
+namespace quic {
+namespace test {
+
+// A test certificate generated by //net/tools/quic/certs/generate-certs.sh.
+ABSL_CONST_INIT const char kTestCertificateRaw[] = {
+ '\x30', '\x82', '\x03', '\xb4', '\x30', '\x82', '\x02', '\x9c', '\xa0',
+ '\x03', '\x02', '\x01', '\x02', '\x02', '\x01', '\x01', '\x30', '\x0d',
+ '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7', '\x0d', '\x01',
+ '\x01', '\x0b', '\x05', '\x00', '\x30', '\x1e', '\x31', '\x1c', '\x30',
+ '\x1a', '\x06', '\x03', '\x55', '\x04', '\x03', '\x0c', '\x13', '\x51',
+ '\x55', '\x49', '\x43', '\x20', '\x53', '\x65', '\x72', '\x76', '\x65',
+ '\x72', '\x20', '\x52', '\x6f', '\x6f', '\x74', '\x20', '\x43', '\x41',
+ '\x30', '\x1e', '\x17', '\x0d', '\x32', '\x30', '\x30', '\x31', '\x33',
+ '\x30', '\x31', '\x38', '\x31', '\x33', '\x35', '\x39', '\x5a', '\x17',
+ '\x0d', '\x32', '\x30', '\x30', '\x32', '\x30', '\x32', '\x31', '\x38',
+ '\x31', '\x33', '\x35', '\x39', '\x5a', '\x30', '\x64', '\x31', '\x0b',
+ '\x30', '\x09', '\x06', '\x03', '\x55', '\x04', '\x06', '\x13', '\x02',
+ '\x55', '\x53', '\x31', '\x13', '\x30', '\x11', '\x06', '\x03', '\x55',
+ '\x04', '\x08', '\x0c', '\x0a', '\x43', '\x61', '\x6c', '\x69', '\x66',
+ '\x6f', '\x72', '\x6e', '\x69', '\x61', '\x31', '\x16', '\x30', '\x14',
+ '\x06', '\x03', '\x55', '\x04', '\x07', '\x0c', '\x0d', '\x4d', '\x6f',
+ '\x75', '\x6e', '\x74', '\x61', '\x69', '\x6e', '\x20', '\x56', '\x69',
+ '\x65', '\x77', '\x31', '\x14', '\x30', '\x12', '\x06', '\x03', '\x55',
+ '\x04', '\x0a', '\x0c', '\x0b', '\x51', '\x55', '\x49', '\x43', '\x20',
+ '\x53', '\x65', '\x72', '\x76', '\x65', '\x72', '\x31', '\x12', '\x30',
+ '\x10', '\x06', '\x03', '\x55', '\x04', '\x03', '\x0c', '\x09', '\x31',
+ '\x32', '\x37', '\x2e', '\x30', '\x2e', '\x30', '\x2e', '\x31', '\x30',
+ '\x82', '\x01', '\x22', '\x30', '\x0d', '\x06', '\x09', '\x2a', '\x86',
+ '\x48', '\x86', '\xf7', '\x0d', '\x01', '\x01', '\x01', '\x05', '\x00',
+ '\x03', '\x82', '\x01', '\x0f', '\x00', '\x30', '\x82', '\x01', '\x0a',
+ '\x02', '\x82', '\x01', '\x01', '\x00', '\xc5', '\xe2', '\x51', '\x6d',
+ '\x3f', '\xd6', '\x28', '\xf2', '\xad', '\x34', '\x73', '\x87', '\x64',
+ '\xca', '\x33', '\x19', '\x33', '\xb7', '\x75', '\x91', '\xab', '\x31',
+ '\x19', '\x2b', '\xe3', '\xa4', '\x26', '\x09', '\x29', '\x8b', '\x2d',
+ '\xf7', '\x52', '\x75', '\xa7', '\x55', '\x15', '\xf0', '\x11', '\xc7',
+ '\xc2', '\xc4', '\xed', '\x18', '\x1b', '\x33', '\x0b', '\x71', '\x32',
+ '\xe6', '\x35', '\x89', '\xcd', '\x2d', '\x5a', '\x05', '\x57', '\x4e',
+ '\xc2', '\x78', '\x75', '\x65', '\x72', '\x2d', '\x8a', '\x17', '\x83',
+ '\xd6', '\x32', '\x90', '\x85', '\xf8', '\x22', '\xe2', '\x65', '\xa9',
+ '\xe0', '\xa0', '\xfe', '\x19', '\xb2', '\x39', '\x2d', '\x14', '\x03',
+ '\x10', '\x2f', '\xcc', '\x8b', '\x5e', '\xaa', '\x25', '\x27', '\x0d',
+ '\xa3', '\x37', '\x10', '\x0c', '\x17', '\xec', '\xf0', '\x8b', '\xc5',
+ '\x6b', '\xed', '\x6b', '\x5e', '\xb2', '\xe2', '\x35', '\x3e', '\x46',
+ '\x3b', '\xf7', '\xf6', '\x59', '\xb1', '\xe0', '\x16', '\xa6', '\xfb',
+ '\x03', '\xbf', '\x84', '\x4f', '\xce', '\x64', '\x15', '\x0d', '\x59',
+ '\x99', '\xa6', '\xf0', '\x7f', '\x8a', '\x33', '\x4b', '\xbb', '\x0b',
+ '\xb8', '\xf2', '\xd1', '\x27', '\x90', '\x8f', '\x38', '\xf8', '\x5a',
+ '\x41', '\x82', '\x07', '\x9b', '\x0d', '\xd9', '\x52', '\xe0', '\x70',
+ '\xff', '\xde', '\xda', '\xd8', '\x25', '\x4e', '\x2f', '\x2d', '\x9f',
+ '\xaf', '\x92', '\x63', '\xc7', '\x42', '\xb4', '\xdc', '\x16', '\x95',
+ '\x23', '\x05', '\x02', '\x6b', '\xb0', '\xe8', '\xc5', '\xfe', '\x15',
+ '\x9a', '\xe8', '\x7d', '\x2f', '\xdc', '\x43', '\xf4', '\x70', '\x91',
+ '\x1a', '\x93', '\xbe', '\x71', '\xaf', '\x85', '\x84', '\xdb', '\xcf',
+ '\x6b', '\x5c', '\x80', '\xb2', '\xd3', '\xf3', '\x42', '\x6e', '\x24',
+ '\xec', '\x2a', '\x62', '\x99', '\xc6', '\x3c', '\xe5', '\x32', '\xe5',
+ '\x72', '\x37', '\x30', '\x9b', '\x0b', '\xe4', '\x06', '\xb4', '\x64',
+ '\x26', '\x95', '\x59', '\xba', '\xf1', '\x53', '\x83', '\x3d', '\x99',
+ '\x6d', '\xf0', '\x80', '\xe2', '\xdb', '\x6b', '\x34', '\x52', '\x06',
+ '\x77', '\x3c', '\x73', '\xbe', '\xc6', '\xe3', '\xce', '\xb2', '\x11',
+ '\x02', '\x03', '\x01', '\x00', '\x01', '\xa3', '\x81', '\xb6', '\x30',
+ '\x81', '\xb3', '\x30', '\x0c', '\x06', '\x03', '\x55', '\x1d', '\x13',
+ '\x01', '\x01', '\xff', '\x04', '\x02', '\x30', '\x00', '\x30', '\x1d',
+ '\x06', '\x03', '\x55', '\x1d', '\x0e', '\x04', '\x16', '\x04', '\x14',
+ '\xc8', '\x54', '\x28', '\xf6', '\xd2', '\xd5', '\x12', '\x35', '\x89',
+ '\x15', '\x75', '\xb8', '\xbf', '\xdd', '\xfb', '\x4a', '\xfc', '\x6c',
+ '\x89', '\xde', '\x30', '\x1f', '\x06', '\x03', '\x55', '\x1d', '\x23',
+ '\x04', '\x18', '\x30', '\x16', '\x80', '\x14', '\x50', '\xe4', '\x1d',
+ '\xc3', '\x1a', '\xfb', '\xfd', '\x38', '\xdd', '\xa2', '\x05', '\xfd',
+ '\xc8', '\xfa', '\x57', '\x0a', '\xc1', '\x06', '\x0f', '\xae', '\x30',
+ '\x1d', '\x06', '\x03', '\x55', '\x1d', '\x25', '\x04', '\x16', '\x30',
+ '\x14', '\x06', '\x08', '\x2b', '\x06', '\x01', '\x05', '\x05', '\x07',
+ '\x03', '\x01', '\x06', '\x08', '\x2b', '\x06', '\x01', '\x05', '\x05',
+ '\x07', '\x03', '\x02', '\x30', '\x44', '\x06', '\x03', '\x55', '\x1d',
+ '\x11', '\x04', '\x3d', '\x30', '\x3b', '\x82', '\x0f', '\x77', '\x77',
+ '\x77', '\x2e', '\x65', '\x78', '\x61', '\x6d', '\x70', '\x6c', '\x65',
+ '\x2e', '\x6f', '\x72', '\x67', '\x82', '\x10', '\x6d', '\x61', '\x69',
+ '\x6c', '\x2e', '\x65', '\x78', '\x61', '\x6d', '\x70', '\x6c', '\x65',
+ '\x2e', '\x6f', '\x72', '\x67', '\x82', '\x10', '\x6d', '\x61', '\x69',
+ '\x6c', '\x2e', '\x65', '\x78', '\x61', '\x6d', '\x70', '\x6c', '\x65',
+ '\x2e', '\x63', '\x6f', '\x6d', '\x87', '\x04', '\x7f', '\x00', '\x00',
+ '\x01', '\x30', '\x0d', '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86',
+ '\xf7', '\x0d', '\x01', '\x01', '\x0b', '\x05', '\x00', '\x03', '\x82',
+ '\x01', '\x01', '\x00', '\x45', '\x41', '\x7a', '\x68', '\xe0', '\xa7',
+ '\x59', '\xa1', '\x62', '\x54', '\x73', '\x74', '\x14', '\x4f', '\xde',
+ '\x9c', '\x51', '\xac', '\x25', '\x97', '\x70', '\xf7', '\x09', '\x51',
+ '\x39', '\x72', '\x39', '\x3c', '\xd0', '\x31', '\xe1', '\xc3', '\x02',
+ '\x91', '\x14', '\x4d', '\x8f', '\x1d', '\x31', '\xab', '\x98', '\x7e',
+ '\xe6', '\xbb', '\xab', '\x6a', '\xd9', '\xc5', '\x86', '\xaa', '\x4e',
+ '\x6a', '\x48', '\xe9', '\xf8', '\xd7', '\xb3', '\x1d', '\xa0', '\xc5',
+ '\xe6', '\xbf', '\x4c', '\x5a', '\x9b', '\xb5', '\x78', '\x01', '\xa3',
+ '\x39', '\x7b', '\x5f', '\xbc', '\xb8', '\xa7', '\xc2', '\x71', '\xb0',
+ '\x7b', '\xdd', '\xa1', '\x87', '\xa6', '\x54', '\x9c', '\xf6', '\x59',
+ '\x81', '\xb1', '\x2c', '\xde', '\xc5', '\x8a', '\xa2', '\x06', '\x89',
+ '\xb5', '\xc1', '\x7a', '\xbe', '\x0c', '\x9f', '\x3d', '\xde', '\x81',
+ '\x48', '\x53', '\x71', '\x7b', '\x8d', '\xc7', '\xea', '\x87', '\xd7',
+ '\xd1', '\xda', '\x94', '\xb4', '\xc5', '\xac', '\x1e', '\x83', '\xa3',
+ '\x42', '\x7d', '\xe6', '\xab', '\x3f', '\xd6', '\x1c', '\xd6', '\x65',
+ '\xc3', '\x60', '\xe9', '\x76', '\x54', '\x79', '\x3f', '\xeb', '\x65',
+ '\x85', '\x4f', '\x60', '\x7d', '\xbb', '\x96', '\x03', '\x54', '\x2e',
+ '\xd0', '\x1b', '\xe2', '\x6c', '\x2d', '\x91', '\xae', '\x33', '\x9c',
+ '\x04', '\xc4', '\x44', '\x0a', '\x7d', '\x5f', '\xbb', '\x80', '\xa2',
+ '\x01', '\xbc', '\x90', '\x81', '\xa5', '\xdc', '\x4a', '\xc8', '\x77',
+ '\xc9', '\x8d', '\x34', '\x17', '\xe6', '\x2a', '\x7d', '\x02', '\x1e',
+ '\x32', '\x3f', '\x7d', '\xd7', '\x0c', '\x80', '\x5b', '\xc6', '\x94',
+ '\x6a', '\x42', '\x36', '\x05', '\x9f', '\x9e', '\xc5', '\x85', '\x9f',
+ '\x60', '\xe3', '\x72', '\x73', '\x34', '\x39', '\x44', '\x75', '\x55',
+ '\x60', '\x24', '\x7a', '\x8b', '\x09', '\x74', '\x84', '\x72', '\xfd',
+ '\x91', '\x68', '\x93', '\x57', '\x9e', '\x70', '\x46', '\x4d', '\xe4',
+ '\x30', '\x84', '\x5f', '\x20', '\x07', '\xad', '\xfd', '\x86', '\x32',
+ '\xd3', '\xfb', '\xba', '\xaf', '\xd9', '\x61', '\x14', '\x3c', '\xe0',
+ '\xa1', '\xa9', '\x51', '\x51', '\x0f', '\xad', '\x60'};
+
+ABSL_CONST_INIT const absl::string_view kTestCertificate(
+ kTestCertificateRaw,
+ sizeof(kTestCertificateRaw));
+
+ABSL_CONST_INIT const char kTestCertificatePem[] =
+ R"(Certificate:
+ Data:
+ Version: 3 (0x2)
+ Serial Number: 1 (0x1)
+ Signature Algorithm: sha256WithRSAEncryption
+ Issuer: CN=QUIC Server Root CA
+ Validity
+ Not Before: Jan 30 18:13:59 2020 GMT
+ Not After : Feb 2 18:13:59 2020 GMT
+ Subject: C=US, ST=California, L=Mountain View, O=QUIC Server, CN=127.0.0.1
+ Subject Public Key Info:
+ Public Key Algorithm: rsaEncryption
+ RSA Public-Key: (2048 bit)
+ Modulus:
+ 00:c5:e2:51:6d:3f:d6:28:f2:ad:34:73:87:64:ca:
+ 33:19:33:b7:75:91:ab:31:19:2b:e3:a4:26:09:29:
+ 8b:2d:f7:52:75:a7:55:15:f0:11:c7:c2:c4:ed:18:
+ 1b:33:0b:71:32:e6:35:89:cd:2d:5a:05:57:4e:c2:
+ 78:75:65:72:2d:8a:17:83:d6:32:90:85:f8:22:e2:
+ 65:a9:e0:a0:fe:19:b2:39:2d:14:03:10:2f:cc:8b:
+ 5e:aa:25:27:0d:a3:37:10:0c:17:ec:f0:8b:c5:6b:
+ ed:6b:5e:b2:e2:35:3e:46:3b:f7:f6:59:b1:e0:16:
+ a6:fb:03:bf:84:4f:ce:64:15:0d:59:99:a6:f0:7f:
+ 8a:33:4b:bb:0b:b8:f2:d1:27:90:8f:38:f8:5a:41:
+ 82:07:9b:0d:d9:52:e0:70:ff:de:da:d8:25:4e:2f:
+ 2d:9f:af:92:63:c7:42:b4:dc:16:95:23:05:02:6b:
+ b0:e8:c5:fe:15:9a:e8:7d:2f:dc:43:f4:70:91:1a:
+ 93:be:71:af:85:84:db:cf:6b:5c:80:b2:d3:f3:42:
+ 6e:24:ec:2a:62:99:c6:3c:e5:32:e5:72:37:30:9b:
+ 0b:e4:06:b4:64:26:95:59:ba:f1:53:83:3d:99:6d:
+ f0:80:e2:db:6b:34:52:06:77:3c:73:be:c6:e3:ce:
+ b2:11
+ Exponent: 65537 (0x10001)
+ X509v3 extensions:
+ X509v3 Basic Constraints: critical
+ CA:FALSE
+ X509v3 Subject Key Identifier:
+ C8:54:28:F6:D2:D5:12:35:89:15:75:B8:BF:DD:FB:4A:FC:6C:89:DE
+ X509v3 Authority Key Identifier:
+ keyid:50:E4:1D:C3:1A:FB:FD:38:DD:A2:05:FD:C8:FA:57:0A:C1:06:0F:AE
+
+ X509v3 Extended Key Usage:
+ TLS Web Server Authentication, TLS Web Client Authentication
+ X509v3 Subject Alternative Name:
+ DNS:www.example.org, DNS:mail.example.org, DNS:mail.example.com, IP Address:127.0.0.1
+ Signature Algorithm: sha256WithRSAEncryption
+ 45:41:7a:68:e0:a7:59:a1:62:54:73:74:14:4f:de:9c:51:ac:
+ 25:97:70:f7:09:51:39:72:39:3c:d0:31:e1:c3:02:91:14:4d:
+ 8f:1d:31:ab:98:7e:e6:bb:ab:6a:d9:c5:86:aa:4e:6a:48:e9:
+ f8:d7:b3:1d:a0:c5:e6:bf:4c:5a:9b:b5:78:01:a3:39:7b:5f:
+ bc:b8:a7:c2:71:b0:7b:dd:a1:87:a6:54:9c:f6:59:81:b1:2c:
+ de:c5:8a:a2:06:89:b5:c1:7a:be:0c:9f:3d:de:81:48:53:71:
+ 7b:8d:c7:ea:87:d7:d1:da:94:b4:c5:ac:1e:83:a3:42:7d:e6:
+ ab:3f:d6:1c:d6:65:c3:60:e9:76:54:79:3f:eb:65:85:4f:60:
+ 7d:bb:96:03:54:2e:d0:1b:e2:6c:2d:91:ae:33:9c:04:c4:44:
+ 0a:7d:5f:bb:80:a2:01:bc:90:81:a5:dc:4a:c8:77:c9:8d:34:
+ 17:e6:2a:7d:02:1e:32:3f:7d:d7:0c:80:5b:c6:94:6a:42:36:
+ 05:9f:9e:c5:85:9f:60:e3:72:73:34:39:44:75:55:60:24:7a:
+ 8b:09:74:84:72:fd:91:68:93:57:9e:70:46:4d:e4:30:84:5f:
+ 20:07:ad:fd:86:32:d3:fb:ba:af:d9:61:14:3c:e0:a1:a9:51:
+ 51:0f:ad:60
+-----BEGIN CERTIFICATE-----
+MIIDtDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAeMRwwGgYDVQQDDBNRVUlD
+IFNlcnZlciBSb290IENBMB4XDTIwMDEzMDE4MTM1OVoXDTIwMDIwMjE4MTM1OVow
+ZDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1v
+dW50YWluIFZpZXcxFDASBgNVBAoMC1FVSUMgU2VydmVyMRIwEAYDVQQDDAkxMjcu
+MC4wLjEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDF4lFtP9Yo8q00
+c4dkyjMZM7d1kasxGSvjpCYJKYst91J1p1UV8BHHwsTtGBszC3Ey5jWJzS1aBVdO
+wnh1ZXItiheD1jKQhfgi4mWp4KD+GbI5LRQDEC/Mi16qJScNozcQDBfs8IvFa+1r
+XrLiNT5GO/f2WbHgFqb7A7+ET85kFQ1Zmabwf4ozS7sLuPLRJ5CPOPhaQYIHmw3Z
+UuBw/97a2CVOLy2fr5Jjx0K03BaVIwUCa7Doxf4Vmuh9L9xD9HCRGpO+ca+FhNvP
+a1yAstPzQm4k7CpimcY85TLlcjcwmwvkBrRkJpVZuvFTgz2ZbfCA4ttrNFIGdzxz
+vsbjzrIRAgMBAAGjgbYwgbMwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUyFQo9tLV
+EjWJFXW4v937Svxsid4wHwYDVR0jBBgwFoAUUOQdwxr7/TjdogX9yPpXCsEGD64w
+HQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMEQGA1UdEQQ9MDuCD3d3dy5l
+eGFtcGxlLm9yZ4IQbWFpbC5leGFtcGxlLm9yZ4IQbWFpbC5leGFtcGxlLmNvbYcE
+fwAAATANBgkqhkiG9w0BAQsFAAOCAQEARUF6aOCnWaFiVHN0FE/enFGsJZdw9wlR
+OXI5PNAx4cMCkRRNjx0xq5h+5ruratnFhqpOakjp+NezHaDF5r9MWpu1eAGjOXtf
+vLinwnGwe92hh6ZUnPZZgbEs3sWKogaJtcF6vgyfPd6BSFNxe43H6ofX0dqUtMWs
+HoOjQn3mqz/WHNZlw2DpdlR5P+tlhU9gfbuWA1Qu0BvibC2RrjOcBMRECn1fu4Ci
+AbyQgaXcSsh3yY00F+YqfQIeMj991wyAW8aUakI2BZ+exYWfYONyczQ5RHVVYCR6
+iwl0hHL9kWiTV55wRk3kMIRfIAet/YYy0/u6r9lhFDzgoalRUQ+tYA==
+-----END CERTIFICATE-----)";
+
+// Same leaf as above, but with an intermediary attached.
+ABSL_CONST_INIT const char kTestCertificateChainPem[] =
+ R"(-----BEGIN CERTIFICATE-----
+MIIDtDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAeMRwwGgYDVQQDDBNRVUlD
+IFNlcnZlciBSb290IENBMB4XDTIwMDEzMDE4MTM1OVoXDTIwMDIwMjE4MTM1OVow
+ZDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1v
+dW50YWluIFZpZXcxFDASBgNVBAoMC1FVSUMgU2VydmVyMRIwEAYDVQQDDAkxMjcu
+MC4wLjEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDF4lFtP9Yo8q00
+c4dkyjMZM7d1kasxGSvjpCYJKYst91J1p1UV8BHHwsTtGBszC3Ey5jWJzS1aBVdO
+wnh1ZXItiheD1jKQhfgi4mWp4KD+GbI5LRQDEC/Mi16qJScNozcQDBfs8IvFa+1r
+XrLiNT5GO/f2WbHgFqb7A7+ET85kFQ1Zmabwf4ozS7sLuPLRJ5CPOPhaQYIHmw3Z
+UuBw/97a2CVOLy2fr5Jjx0K03BaVIwUCa7Doxf4Vmuh9L9xD9HCRGpO+ca+FhNvP
+a1yAstPzQm4k7CpimcY85TLlcjcwmwvkBrRkJpVZuvFTgz2ZbfCA4ttrNFIGdzxz
+vsbjzrIRAgMBAAGjgbYwgbMwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUyFQo9tLV
+EjWJFXW4v937Svxsid4wHwYDVR0jBBgwFoAUUOQdwxr7/TjdogX9yPpXCsEGD64w
+HQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMEQGA1UdEQQ9MDuCD3d3dy5l
+eGFtcGxlLm9yZ4IQbWFpbC5leGFtcGxlLm9yZ4IQbWFpbC5leGFtcGxlLmNvbYcE
+fwAAATANBgkqhkiG9w0BAQsFAAOCAQEARUF6aOCnWaFiVHN0FE/enFGsJZdw9wlR
+OXI5PNAx4cMCkRRNjx0xq5h+5ruratnFhqpOakjp+NezHaDF5r9MWpu1eAGjOXtf
+vLinwnGwe92hh6ZUnPZZgbEs3sWKogaJtcF6vgyfPd6BSFNxe43H6ofX0dqUtMWs
+HoOjQn3mqz/WHNZlw2DpdlR5P+tlhU9gfbuWA1Qu0BvibC2RrjOcBMRECn1fu4Ci
+AbyQgaXcSsh3yY00F+YqfQIeMj991wyAW8aUakI2BZ+exYWfYONyczQ5RHVVYCR6
+iwl0hHL9kWiTV55wRk3kMIRfIAet/YYy0/u6r9lhFDzgoalRUQ+tYA==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDDDCCAfSgAwIBAgIUfVS7RH+aVGqZhrjyuyD4qCnTS+MwDQYJKoZIhvcNAQEL
+BQAwHjEcMBoGA1UEAwwTUVVJQyBTZXJ2ZXIgUm9vdCBDQTAeFw0yMDAxMzAxODEz
+NTlaFw0yMDAyMDIxODEzNTlaMB4xHDAaBgNVBAMME1FVSUMgU2VydmVyIFJvb3Qg
+Q0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCc3k0GGpCBf6jXHxia
+QM4ntB6pWkT+NbaZUNHb1SkG2Cp9dN5dEKOXiqOi9306j4WNWTq/q0Ku9lCPPPFs
+JTIVC3tKY8Nbiczw+mohgW4rwLgpAP5rjjVzTxSFpDWZlgkH54HpqLjJFVl4Fklg
+vzSj+rYfqP+ueesi7z7KwPwzd30jjsJlpr2rlkZkidWT5vRTD3uYhNOW7IIT0lRP
+MDTwdxTEU5unyxESAsZyckNuJDeNF0y1Aw5Xiw/Bww+CyRH+tX6OUcWNtA+ZSDU8
+oVH5m4rxYK/DaHAZrA672/ywvUcPQaNaRxsAWRVjhktgyGPT3pjqiHDCN8+42uhH
+SgrbAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFDkHcMa+/04
+3aIF/cj6VwrBBg+uMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEA
+iX+tn1Zfxx4M5YqZlPgXFB219agrJP2vM0fzW0E4zqDvA2ALaQN+lwdnFueN3tDk
+3IJvxd2W5k1Qh7LqWFUbBghDAP43XffW/yNy0+nuR2n3nRYdNStSMrGQm7oywhBd
+5jQl0GQUyYf1jcbD76HA5JraBjEXnQyJe6gJYHiRiMaMURWyzcngOPv5w3XBzIe3
+sRM0Rk/TTZP1Qx7fDY3ikFe1w9LzAMGbKDTKfc1+F0GZByJ3pdWakUNXZvtGFhIF
+hTXMooR/wD7an6gtnXD8ixCh7bP0TyPiBhNsUb12WrvSEAm/UyciQbQlR7P+K0Z7
+Cmn1Mj4hQ+pT0t+pw/DMOw==
+-----END CERTIFICATE-----)";
+
+ABSL_CONST_INIT const char kTestCertWithUnknownSanTypePem[] =
+ R"(-----BEGIN CERTIFICATE-----
+MIIEYTCCA0mgAwIBAgIJAILStmLgUUcVMA0GCSqGSIb3DQEBCwUAMHYxCzAJBgNV
+BAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNp
+c2NvMQ0wCwYDVQQKDARMeWZ0MRkwFwYDVQQLDBBMeWZ0IEVuZ2luZWVyaW5nMRAw
+DgYDVQQDDAdUZXN0IENBMB4XDTE4MTIxNzIwMTgwMFoXDTIwMTIxNjIwMTgwMFow
+gaYxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1T
+YW4gRnJhbmNpc2NvMQ0wCwYDVQQKDARMeWZ0MRkwFwYDVQQLDBBMeWZ0IEVuZ2lu
+ZWVyaW5nMRowGAYDVQQDDBFUZXN0IEJhY2tlbmQgVGVhbTEkMCIGCSqGSIb3DQEJ
+ARYVYmFja2VuZC10ZWFtQGx5ZnQuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAuvPdQdmwZongPAgQho/Vipd3PZWrQ6BKxIb4l/RvqtVP321IUTLs
+4vVwpXoYJ+12L+XOO3jCInszs53tHjFpTI1GE8/sasmgR6LRr2krwSoVRHPqUoc9
+tzkDG1SzKP2TRTi1MTI3FO+TnLFahntO9Zstxhv1Epz5GZ/xQLE0/LLoRYzcynL/
+iflk18iL1KM8i0Hy4cKjclOaUdnh2nh753iJfxCSb5wJfx4FH1qverYHHT6FopYR
+V40Cg0yYXcYo8yNwrg+EBY8QAT2JOMDokXNKbZpmVKiBlh0QYMX6BBiW249v3sYl
+3Ve+fZvCkle3W0xP0xJw8PdX0NRbvGOrBQIDAQABo4HAMIG9MAwGA1UdEwEB/wQC
+MAAwCwYDVR0PBAQDAgXgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATBB
+BgNVHREEOjA4hh5zcGlmZmU6Ly9seWZ0LmNvbS9iYWNrZW5kLXRlYW2CCGx5ZnQu
+Y29tggx3d3cubHlmdC5jb20wHQYDVR0OBBYEFLHmMm0DV9jCHJSWVRwyPYpBw62r
+MB8GA1UdIwQYMBaAFBQz1vaSbPuePL++7GTMqLAMtk3kMA0GCSqGSIb3DQEBCwUA
+A4IBAQAwx3/M2o00W8GlQ3OT4y/hQGb5K2aytxx8QeSmJaaZTJbvaHhe0x3/fLgq
+uWrW3WEWFtwasilySjOrFOtB9UNmJmNOHSJD3Bslbv5htRaWnoFPCXdwZtVMdoTq
+IHIQqLoos/xj3kVD5sJSYySrveMeKaeUILTkb5ZubSivye1X2yiJLR7AtuwuiMio
+CdIOqhn6xJqYhT7z0IhdKpLNPk4w1tBZSKOXqzrXS4uoJgTC67hWslWWZ2VC6IvZ
+FmKuuGZamCCj6F1QF2IjMVM8evl84hEnN0ajdkA/QWnil9kcWvBm15Ho+oTvvJ7s
+M8MD3RDSq/90FSiME4vbyNEyTmj0
+-----END CERTIFICATE-----)";
+
+ABSL_CONST_INIT const char kTestCertificatePrivateKeyRaw[] = {
+ '\x30', '\x82', '\x04', '\xbc', '\x02', '\x01', '\x00', '\x30', '\x0d',
+ '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7', '\x0d', '\x01',
+ '\x01', '\x01', '\x05', '\x00', '\x04', '\x82', '\x04', '\xa6', '\x30',
+ '\x82', '\x04', '\xa2', '\x02', '\x01', '\x00', '\x02', '\x82', '\x01',
+ '\x01', '\x00', '\xc5', '\xe2', '\x51', '\x6d', '\x3f', '\xd6', '\x28',
+ '\xf2', '\xad', '\x34', '\x73', '\x87', '\x64', '\xca', '\x33', '\x19',
+ '\x33', '\xb7', '\x75', '\x91', '\xab', '\x31', '\x19', '\x2b', '\xe3',
+ '\xa4', '\x26', '\x09', '\x29', '\x8b', '\x2d', '\xf7', '\x52', '\x75',
+ '\xa7', '\x55', '\x15', '\xf0', '\x11', '\xc7', '\xc2', '\xc4', '\xed',
+ '\x18', '\x1b', '\x33', '\x0b', '\x71', '\x32', '\xe6', '\x35', '\x89',
+ '\xcd', '\x2d', '\x5a', '\x05', '\x57', '\x4e', '\xc2', '\x78', '\x75',
+ '\x65', '\x72', '\x2d', '\x8a', '\x17', '\x83', '\xd6', '\x32', '\x90',
+ '\x85', '\xf8', '\x22', '\xe2', '\x65', '\xa9', '\xe0', '\xa0', '\xfe',
+ '\x19', '\xb2', '\x39', '\x2d', '\x14', '\x03', '\x10', '\x2f', '\xcc',
+ '\x8b', '\x5e', '\xaa', '\x25', '\x27', '\x0d', '\xa3', '\x37', '\x10',
+ '\x0c', '\x17', '\xec', '\xf0', '\x8b', '\xc5', '\x6b', '\xed', '\x6b',
+ '\x5e', '\xb2', '\xe2', '\x35', '\x3e', '\x46', '\x3b', '\xf7', '\xf6',
+ '\x59', '\xb1', '\xe0', '\x16', '\xa6', '\xfb', '\x03', '\xbf', '\x84',
+ '\x4f', '\xce', '\x64', '\x15', '\x0d', '\x59', '\x99', '\xa6', '\xf0',
+ '\x7f', '\x8a', '\x33', '\x4b', '\xbb', '\x0b', '\xb8', '\xf2', '\xd1',
+ '\x27', '\x90', '\x8f', '\x38', '\xf8', '\x5a', '\x41', '\x82', '\x07',
+ '\x9b', '\x0d', '\xd9', '\x52', '\xe0', '\x70', '\xff', '\xde', '\xda',
+ '\xd8', '\x25', '\x4e', '\x2f', '\x2d', '\x9f', '\xaf', '\x92', '\x63',
+ '\xc7', '\x42', '\xb4', '\xdc', '\x16', '\x95', '\x23', '\x05', '\x02',
+ '\x6b', '\xb0', '\xe8', '\xc5', '\xfe', '\x15', '\x9a', '\xe8', '\x7d',
+ '\x2f', '\xdc', '\x43', '\xf4', '\x70', '\x91', '\x1a', '\x93', '\xbe',
+ '\x71', '\xaf', '\x85', '\x84', '\xdb', '\xcf', '\x6b', '\x5c', '\x80',
+ '\xb2', '\xd3', '\xf3', '\x42', '\x6e', '\x24', '\xec', '\x2a', '\x62',
+ '\x99', '\xc6', '\x3c', '\xe5', '\x32', '\xe5', '\x72', '\x37', '\x30',
+ '\x9b', '\x0b', '\xe4', '\x06', '\xb4', '\x64', '\x26', '\x95', '\x59',
+ '\xba', '\xf1', '\x53', '\x83', '\x3d', '\x99', '\x6d', '\xf0', '\x80',
+ '\xe2', '\xdb', '\x6b', '\x34', '\x52', '\x06', '\x77', '\x3c', '\x73',
+ '\xbe', '\xc6', '\xe3', '\xce', '\xb2', '\x11', '\x02', '\x03', '\x01',
+ '\x00', '\x01', '\x02', '\x82', '\x01', '\x00', '\x39', '\x75', '\xac',
+ '\x1b', '\x43', '\x0c', '\x16', '\xbb', '\xd0', '\xdb', '\x88', '\x28',
+ '\x6a', '\x75', '\xe4', '\x3c', '\x8f', '\x2d', '\xd8', '\x6f', '\xc1',
+ '\xfb', '\xf1', '\xc9', '\x32', '\xc2', '\xb9', '\x60', '\xb3', '\xb5',
+ '\x7c', '\x55', '\x72', '\x96', '\x43', '\x4e', '\x8b', '\x9e', '\x38',
+ '\x2b', '\x7f', '\x3c', '\xdb', '\x73', '\xc2', '\x82', '\x21', '\xf2',
+ '\x6e', '\xcb', '\x36', '\x04', '\x9b', '\x95', '\x6d', '\xac', '\x5b',
+ '\x5b', '\xbd', '\x50', '\x69', '\x16', '\x59', '\xff', '\x2b', '\x38',
+ '\x04', '\xca', '\x2f', '\xc8', '\x93', '\x7e', '\x27', '\xf3', '\x01',
+ '\x7e', '\x40', '\x81', '\xbf', '\x07', '\x0b', '\x1f', '\x5b', '\x1d',
+ '\x92', '\x7e', '\x22', '\xc3', '\x0c', '\x3d', '\x22', '\xbe', '\xc3',
+ '\x06', '\x4c', '\xbc', '\x72', '\x66', '\x70', '\x94', '\x16', '\x8d',
+ '\x1f', '\x78', '\x65', '\x6a', '\x66', '\x07', '\x1f', '\x74', '\x42',
+ '\x6e', '\xf6', '\x7e', '\xdc', '\x03', '\xd3', '\x88', '\xb4', '\x4b',
+ '\x2c', '\x5c', '\x3c', '\x42', '\x59', '\x42', '\x1f', '\x01', '\x13',
+ '\x31', '\xc5', '\x22', '\xe7', '\x6a', '\x96', '\xf2', '\xfb', '\x66',
+ '\xfe', '\xc8', '\xa1', '\x7e', '\x24', '\x96', '\x5f', '\x02', '\xee',
+ '\x38', '\x21', '\xa5', '\x14', '\xd2', '\xa6', '\x35', '\x70', '\x6c',
+ '\x8d', '\xa6', '\xd8', '\x2a', '\xd2', '\x45', '\x31', '\x5f', '\x67',
+ '\x9e', '\x35', '\x57', '\x6a', '\xc4', '\x15', '\xe7', '\xba', '\x60',
+ '\x2f', '\x8e', '\x52', '\x4e', '\xfc', '\x6f', '\xa0', '\x08', '\x91',
+ '\x31', '\x71', '\x06', '\x68', '\x19', '\x48', '\xc7', '\x81', '\x0d',
+ '\x5e', '\x52', '\x93', '\x57', '\xcc', '\xfe', '\x46', '\xac', '\xa9',
+ '\x4f', '\xe2', '\x96', '\x4f', '\xaf', '\x12', '\xfb', '\xc2', '\x4b',
+ '\xc4', '\x8d', '\x3b', '\xb0', '\x38', '\xe4', '\xbb', '\x8d', '\x19',
+ '\x81', '\xe4', '\x74', '\x63', '\x9c', '\x8d', '\xaa', '\x84', '\x82',
+ '\x91', '\xdf', '\xdc', '\x45', '\xf0', '\x39', '\xb2', '\xb4', '\xac',
+ '\x45', '\xda', '\x3f', '\x30', '\x4d', '\x46', '\xb1', '\xe1', '\xb2',
+ '\x9d', '\xdf', '\xd8', '\xc4', '\xa2', '\xef', '\xe9', '\x1a', '\x97',
+ '\x79', '\x02', '\x81', '\x81', '\x00', '\xe5', '\x23', '\xb8', '\xd7',
+ '\x09', '\x54', '\x54', '\x3b', '\xb6', '\x78', '\x78', '\x67', '\x57',
+ '\x65', '\xc5', '\xd4', '\x74', '\xaf', '\x05', '\x4f', '\xb5', '\xc8',
+ '\x8c', '\x1b', '\xd1', '\x9a', '\x2c', '\xd6', '\xe4', '\x68', '\xd1',
+ '\xaf', '\x3d', '\x72', '\x42', '\x50', '\xc8', '\xdd', '\xb1', '\xee',
+ '\x77', '\x52', '\xb8', '\xb1', '\x31', '\xbe', '\xf0', '\x74', '\x78',
+ '\x42', '\x59', '\xea', '\x13', '\x8b', '\x82', '\x00', '\x54', '\x22',
+ '\xd2', '\x0a', '\x24', '\xb0', '\x1f', '\x1e', '\x76', '\x27', '\xae',
+ '\x63', '\xc6', '\x6b', '\x59', '\x28', '\x1d', '\xa0', '\x9f', '\x42',
+ '\x30', '\xf1', '\xe3', '\x59', '\x1c', '\x4f', '\x31', '\x49', '\xff',
+ '\x45', '\x7e', '\x6b', '\xef', '\xe9', '\x6f', '\xde', '\xaf', '\x1e',
+ '\x04', '\x96', '\x61', '\x4e', '\x9f', '\x58', '\xf5', '\x0d', '\x64',
+ '\x08', '\x48', '\x0a', '\xae', '\xac', '\xe4', '\x76', '\x91', '\xdd',
+ '\x6e', '\x33', '\x97', '\xc5', '\x96', '\xda', '\xff', '\xbc', '\x42',
+ '\x5b', '\x71', '\xb5', '\x76', '\xae', '\x01', '\xb3', '\x02', '\x81',
+ '\x81', '\x00', '\xdd', '\x14', '\xa5', '\x6c', '\x89', '\x2b', '\x80',
+ '\x78', '\xf6', '\xc3', '\x80', '\x4d', '\x53', '\x54', '\xb3', '\x2b',
+ '\x40', '\xce', '\x98', '\x16', '\xa0', '\xbf', '\x72', '\xf1', '\xe3',
+ '\xdc', '\xe9', '\x0b', '\x45', '\x23', '\x86', '\x38', '\x4c', '\x29',
+ '\xf1', '\xa0', '\xe0', '\x2c', '\xfa', '\x86', '\x3f', '\x01', '\x90',
+ '\xc5', '\x1b', '\x96', '\x10', '\x44', '\x84', '\xfb', '\xec', '\x3c',
+ '\x74', '\x6c', '\x0d', '\xcc', '\xc3', '\xcd', '\x1b', '\x28', '\x12',
+ '\xaa', '\xb4', '\x67', '\x80', '\xc8', '\xd9', '\x1b', '\x7d', '\xe7',
+ '\x54', '\x39', '\x03', '\x6d', '\xba', '\xaa', '\x6f', '\xf7', '\x93',
+ '\x1f', '\x94', '\x76', '\xd6', '\xab', '\x9b', '\xda', '\x3d', '\x89',
+ '\x37', '\x83', '\xfe', '\x72', '\x2a', '\xbb', '\x6f', '\x36', '\xc5',
+ '\xe0', '\xae', '\x65', '\xf9', '\xbb', '\xc6', '\xe2', '\x98', '\x0f',
+ '\xbd', '\xf6', '\x22', '\xf8', '\x35', '\x5b', '\x99', '\xe6', '\xff',
+ '\x6d', '\x6e', '\xb2', '\x92', '\x93', '\x64', '\x25', '\xc1', '\xe8',
+ '\x9c', '\x6b', '\x73', '\x2b', '\x02', '\x81', '\x80', '\x13', '\x30',
+ '\x1a', '\x9a', '\x67', '\x3d', '\x98', '\x90', '\x27', '\x87', '\x8f',
+ '\x0d', '\x98', '\x53', '\xfd', '\x6c', '\xfd', '\x18', '\x6a', '\xe9',
+ '\x71', '\xdf', '\x89', '\x5c', '\x0b', '\x01', '\x4e', '\x1f', '\xf0',
+ '\xa0', '\x96', '\x6e', '\x86', '\x46', '\xbb', '\x26', '\xe8', '\xab',
+ '\x27', '\xeb', '\x40', '\x32', '\xbd', '\x24', '\x99', '\x75', '\xd3',
+ '\xcc', '\xed', '\x05', '\x21', '\x62', '\x68', '\xa0', '\x96', '\x12',
+ '\x50', '\xf9', '\x59', '\x7d', '\x5f', '\xf5', '\x1f', '\xa5', '\xfd',
+ '\x5e', '\xf5', '\x4b', '\x85', '\xa2', '\x17', '\xa5', '\x34', '\x55',
+ '\xef', '\x00', '\x2b', '\xf9', '\x15', '\x80', '\xb0', '\xce', '\x30',
+ '\xe2', '\x71', '\x6d', '\xf0', '\x58', '\x39', '\x8e', '\xe2', '\xbf',
+ '\x53', '\x0a', '\xc0', '\x77', '\x97', '\x4e', '\x6e', '\x29', '\x94',
+ '\xdb', '\xba', '\x34', '\xb7', '\x53', '\xad', '\xac', '\xec', '\xb4',
+ '\xc1', '\x22', '\x39', '\xc8', '\x38', '\x3d', '\x63', '\x94', '\x93',
+ '\x35', '\xc0', '\x98', '\xc7', '\xbc', '\xda', '\x63', '\x57', '\xe1',
+ '\x02', '\x81', '\x80', '\x51', '\x71', '\x7c', '\xab', '\x6a', '\x30',
+ '\xe3', '\x68', '\x2c', '\x87', '\xc2', '\xe9', '\x39', '\x8c', '\x97',
+ '\x60', '\x94', '\xc4', '\x46', '\xd4', '\xf7', '\x2c', '\xf0', '\x1c',
+ '\x5a', '\x34', '\x14', '\x89', '\xf9', '\x53', '\x67', '\xeb', '\xaf',
+ '\x6b', '\x38', '\x3f', '\x6a', '\xb6', '\x47', '\x28', '\x53', '\x67',
+ '\xb1', '\x3c', '\x5b', '\xb8', '\x41', '\x8f', '\xec', '\x69', '\x9e',
+ '\x12', '\x7b', '\x55', '\x1f', '\x14', '\x53', '\x01', '\x69', '\x42',
+ '\xae', '\xf5', '\xc1', '\xf5', '\xeb', '\x44', '\x92', '\x6e', '\x85',
+ '\x48', '\x46', '\x07', '\xa6', '\xd2', '\xb2', '\x94', '\x7d', '\x20',
+ '\xf8', '\x4b', '\x06', '\xf7', '\x6c', '\x87', '\xd5', '\xa7', '\x65',
+ '\x49', '\xfa', '\x70', '\x9e', '\xb8', '\xd2', '\x33', '\x30', '\x7a',
+ '\x3e', '\x15', '\x52', '\x49', '\xf0', '\xe1', '\x13', '\x18', '\x80',
+ '\xaa', '\x33', '\xf1', '\xcb', '\xda', '\x22', '\x55', '\xf7', '\x71',
+ '\x58', '\xa1', '\xa8', '\xc9', '\x12', '\x24', '\x48', '\x1d', '\x7c',
+ '\xbc', '\xc3', '\x7a', '\xf5', '\xf7', '\x02', '\x81', '\x80', '\x41',
+ '\x7c', '\xae', '\x6e', '\x48', '\x3f', '\xb5', '\x0b', '\x99', '\xaa',
+ '\xc5', '\xea', '\x81', '\xad', '\x84', '\x6b', '\x29', '\x78', '\x4b',
+ '\x18', '\xdb', '\x0e', '\xd3', '\x3e', '\x60', '\x8b', '\xef', '\x65',
+ '\x4d', '\x58', '\x25', '\x3a', '\x08', '\xb5', '\x21', '\xb6', '\x61',
+ '\x0c', '\xfa', '\xf0', '\x69', '\x78', '\x4e', '\x68', '\x36', '\xdb',
+ '\x41', '\x4b', '\x50', '\xd8', '\xd3', '\x8e', '\x3d', '\x74', '\x80',
+ '\x8e', '\xa0', '\xe6', '\xda', '\xec', '\x70', '\x89', '\x77', '\xb2',
+ '\x9d', '\xd6', '\x6e', '\x0a', '\xc4', '\xbd', '\xf6', '\x9a', '\x07',
+ '\x15', '\xba', '\x55', '\x9f', '\xd4', '\x4d', '\x3a', '\x0f', '\x51',
+ '\x12', '\xa4', '\xd9', '\xc2', '\x98', '\x76', '\xc5', '\xb7', '\x29',
+ '\x40', '\xca', '\xf4', '\xbb', '\x74', '\x2d', '\x71', '\x03', '\x4d',
+ '\xe7', '\x05', '\x75', '\xc0', '\x8d', '\x96', '\x7e', '\x59', '\xa1',
+ '\x8b', '\x3b', '\xa3', '\x2b', '\xa5', '\xa3', '\xc8', '\xf7', '\xd3',
+ '\x3e', '\x6b', '\x2e', '\xfa', '\x4f', '\x4d', '\xe6', '\xbe', '\xd3',
+ '\x59'};
+
+ABSL_CONST_INIT const absl::string_view kTestCertificatePrivateKey(
+ kTestCertificatePrivateKeyRaw,
+ sizeof(kTestCertificatePrivateKeyRaw));
+
+ABSL_CONST_INIT const char kTestCertificatePrivateKeyPem[] =
+ R"(-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDF4lFtP9Yo8q00
+c4dkyjMZM7d1kasxGSvjpCYJKYst91J1p1UV8BHHwsTtGBszC3Ey5jWJzS1aBVdO
+wnh1ZXItiheD1jKQhfgi4mWp4KD+GbI5LRQDEC/Mi16qJScNozcQDBfs8IvFa+1r
+XrLiNT5GO/f2WbHgFqb7A7+ET85kFQ1Zmabwf4ozS7sLuPLRJ5CPOPhaQYIHmw3Z
+UuBw/97a2CVOLy2fr5Jjx0K03BaVIwUCa7Doxf4Vmuh9L9xD9HCRGpO+ca+FhNvP
+a1yAstPzQm4k7CpimcY85TLlcjcwmwvkBrRkJpVZuvFTgz2ZbfCA4ttrNFIGdzxz
+vsbjzrIRAgMBAAECggEAOXWsG0MMFrvQ24goanXkPI8t2G/B+/HJMsK5YLO1fFVy
+lkNOi544K38823PCgiHybss2BJuVbaxbW71QaRZZ/ys4BMovyJN+J/MBfkCBvwcL
+H1sdkn4iwww9Ir7DBky8cmZwlBaNH3hlamYHH3RCbvZ+3APTiLRLLFw8QllCHwET
+McUi52qW8vtm/sihfiSWXwLuOCGlFNKmNXBsjabYKtJFMV9nnjVXasQV57pgL45S
+TvxvoAiRMXEGaBlIx4ENXlKTV8z+RqypT+KWT68S+8JLxI07sDjku40ZgeR0Y5yN
+qoSCkd/cRfA5srSsRdo/ME1GseGynd/YxKLv6RqXeQKBgQDlI7jXCVRUO7Z4eGdX
+ZcXUdK8FT7XIjBvRmizW5GjRrz1yQlDI3bHud1K4sTG+8HR4QlnqE4uCAFQi0gok
+sB8edieuY8ZrWSgdoJ9CMPHjWRxPMUn/RX5r7+lv3q8eBJZhTp9Y9Q1kCEgKrqzk
+dpHdbjOXxZba/7xCW3G1dq4BswKBgQDdFKVsiSuAePbDgE1TVLMrQM6YFqC/cvHj
+3OkLRSOGOEwp8aDgLPqGPwGQxRuWEESE++w8dGwNzMPNGygSqrRngMjZG33nVDkD
+bbqqb/eTH5R21qub2j2JN4P+ciq7bzbF4K5l+bvG4pgPvfYi+DVbmeb/bW6ykpNk
+JcHonGtzKwKBgBMwGppnPZiQJ4ePDZhT/Wz9GGrpcd+JXAsBTh/woJZuhka7Juir
+J+tAMr0kmXXTzO0FIWJooJYSUPlZfV/1H6X9XvVLhaIXpTRV7wAr+RWAsM4w4nFt
+8Fg5juK/UwrAd5dObimU27o0t1OtrOy0wSI5yDg9Y5STNcCYx7zaY1fhAoGAUXF8
+q2ow42gsh8LpOYyXYJTERtT3LPAcWjQUiflTZ+uvazg/arZHKFNnsTxbuEGP7Gme
+EntVHxRTAWlCrvXB9etEkm6FSEYHptKylH0g+EsG92yH1adlSfpwnrjSMzB6PhVS
+SfDhExiAqjPxy9oiVfdxWKGoyRIkSB18vMN69fcCgYBBfK5uSD+1C5mqxeqBrYRr
+KXhLGNsO0z5gi+9lTVglOgi1IbZhDPrwaXhOaDbbQUtQ2NOOPXSAjqDm2uxwiXey
+ndZuCsS99poHFbpVn9RNOg9REqTZwph2xbcpQMr0u3QtcQNN5wV1wI2Wflmhizuj
+K6WjyPfTPmsu+k9N5r7TWQ==
+-----END PRIVATE KEY-----)";
+
+// The legacy version was manually generated from the one above using der2ascii.
+ABSL_CONST_INIT const char kTestCertificatePrivateKeyLegacyPem[] =
+ R"(-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAxeJRbT/WKPKtNHOHZMozGTO3dZGrMRkr46QmCSmLLfdSdadVFfARx8LE7Rgb
+MwtxMuY1ic0tWgVXTsJ4dWVyLYoXg9YykIX4IuJlqeCg/hmyOS0UAxAvzIteqiUnDaM3EAwX7PCL
+xWvta16y4jU+Rjv39lmx4Bam+wO/hE/OZBUNWZmm8H+KM0u7C7jy0SeQjzj4WkGCB5sN2VLgcP/e
+2tglTi8tn6+SY8dCtNwWlSMFAmuw6MX+FZrofS/cQ/RwkRqTvnGvhYTbz2tcgLLT80JuJOwqYpnG
+POUy5XI3MJsL5Aa0ZCaVWbrxU4M9mW3wgOLbazRSBnc8c77G486yEQIDAQABAoIBADl1rBtDDBa7
+0NuIKGp15DyPLdhvwfvxyTLCuWCztXxVcpZDToueOCt/PNtzwoIh8m7LNgSblW2sW1u9UGkWWf8r
+OATKL8iTfifzAX5Agb8HCx9bHZJ+IsMMPSK+wwZMvHJmcJQWjR94ZWpmBx90Qm72ftwD04i0Syxc
+PEJZQh8BEzHFIudqlvL7Zv7IoX4kll8C7jghpRTSpjVwbI2m2CrSRTFfZ541V2rEFee6YC+OUk78
+b6AIkTFxBmgZSMeBDV5Sk1fM/kasqU/ilk+vEvvCS8SNO7A45LuNGYHkdGOcjaqEgpHf3EXwObK0
+rEXaPzBNRrHhsp3f2MSi7+kal3kCgYEA5SO41wlUVDu2eHhnV2XF1HSvBU+1yIwb0Zos1uRo0a89
+ckJQyN2x7ndSuLExvvB0eEJZ6hOLggBUItIKJLAfHnYnrmPGa1koHaCfQjDx41kcTzFJ/0V+a+/p
+b96vHgSWYU6fWPUNZAhICq6s5HaR3W4zl8WW2v+8QltxtXauAbMCgYEA3RSlbIkrgHj2w4BNU1Sz
+K0DOmBagv3Lx49zpC0UjhjhMKfGg4Cz6hj8BkMUblhBEhPvsPHRsDczDzRsoEqq0Z4DI2Rt951Q5
+A226qm/3kx+Udtarm9o9iTeD/nIqu282xeCuZfm7xuKYD732Ivg1W5nm/21uspKTZCXB6JxrcysC
+gYATMBqaZz2YkCeHjw2YU/1s/Rhq6XHfiVwLAU4f8KCWboZGuyboqyfrQDK9JJl108ztBSFiaKCW
+ElD5WX1f9R+l/V71S4WiF6U0Ve8AK/kVgLDOMOJxbfBYOY7iv1MKwHeXTm4plNu6NLdTrazstMEi
+Ocg4PWOUkzXAmMe82mNX4QKBgFFxfKtqMONoLIfC6TmMl2CUxEbU9yzwHFo0FIn5U2frr2s4P2q2
+RyhTZ7E8W7hBj+xpnhJ7VR8UUwFpQq71wfXrRJJuhUhGB6bSspR9IPhLBvdsh9WnZUn6cJ640jMw
+ej4VUknw4RMYgKoz8cvaIlX3cVihqMkSJEgdfLzDevX3AoGAQXyubkg/tQuZqsXqga2Eayl4Sxjb
+DtM+YIvvZU1YJToItSG2YQz68Gl4Tmg220FLUNjTjj10gI6g5trscIl3sp3WbgrEvfaaBxW6VZ/U
+TToPURKk2cKYdsW3KUDK9Lt0LXEDTecFdcCNln5ZoYs7oyulo8j30z5rLvpPTea+01k=
+-----END RSA PRIVATE KEY-----)";
+
+ABSL_CONST_INIT const char kWildcardCertificateRaw[] = {
+ '\x30', '\x82', '\x03', '\x5f', '\x30', '\x82', '\x02', '\x47', '\xa0',
+ '\x03', '\x02', '\x01', '\x02', '\x02', '\x14', '\x36', '\x1d', '\xe3',
+ '\xd2', '\x39', '\x35', '\x20', '\xb1', '\xae', '\x18', '\xdd', '\x71',
+ '\xc9', '\x5b', '\x4a', '\x17', '\xbe', '\x00', '\xb4', '\x15', '\x30',
+ '\x0d', '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7', '\x0d',
+ '\x01', '\x01', '\x0b', '\x05', '\x00', '\x30', '\x24', '\x31', '\x0b',
+ '\x30', '\x09', '\x06', '\x03', '\x55', '\x04', '\x06', '\x13', '\x02',
+ '\x55', '\x53', '\x31', '\x15', '\x30', '\x13', '\x06', '\x03', '\x55',
+ '\x04', '\x03', '\x0c', '\x0c', '\x77', '\x77', '\x77', '\x2e', '\x66',
+ '\x6f', '\x6f', '\x2e', '\x74', '\x65', '\x73', '\x74', '\x30', '\x1e',
+ '\x17', '\x0d', '\x32', '\x30', '\x30', '\x34', '\x32', '\x31', '\x30',
+ '\x32', '\x31', '\x38', '\x34', '\x35', '\x5a', '\x17', '\x0d', '\x32',
+ '\x31', '\x30', '\x34', '\x32', '\x31', '\x30', '\x32', '\x31', '\x38',
+ '\x34', '\x35', '\x5a', '\x30', '\x24', '\x31', '\x0b', '\x30', '\x09',
+ '\x06', '\x03', '\x55', '\x04', '\x06', '\x13', '\x02', '\x55', '\x53',
+ '\x31', '\x15', '\x30', '\x13', '\x06', '\x03', '\x55', '\x04', '\x03',
+ '\x0c', '\x0c', '\x77', '\x77', '\x77', '\x2e', '\x66', '\x6f', '\x6f',
+ '\x2e', '\x74', '\x65', '\x73', '\x74', '\x30', '\x82', '\x01', '\x22',
+ '\x30', '\x0d', '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7',
+ '\x0d', '\x01', '\x01', '\x01', '\x05', '\x00', '\x03', '\x82', '\x01',
+ '\x0f', '\x00', '\x30', '\x82', '\x01', '\x0a', '\x02', '\x82', '\x01',
+ '\x01', '\x00', '\xcc', '\xd5', '\x5d', '\xa0', '\x4a', '\x03', '\x9d',
+ '\x89', '\xa2', '\xae', '\x7a', '\x59', '\x15', '\xf7', '\x27', '\x67',
+ '\x49', '\xa4', '\xc1', '\x87', '\xcd', '\x9c', '\x02', '\x9e', '\xb9',
+ '\x2f', '\xd1', '\xa1', '\x0d', '\x57', '\xff', '\xd6', '\xc0', '\x6a',
+ '\x7b', '\xaa', '\x52', '\xb2', '\x6e', '\xa6', '\x12', '\x34', '\xcf',
+ '\xdc', '\xd3', '\x1e', '\x32', '\xc1', '\x8d', '\x42', '\xa3', '\x0b',
+ '\xd6', '\xaf', '\xe9', '\x37', '\x42', '\xf8', '\x78', '\xdc', '\xcb',
+ '\x2d', '\x0e', '\x42', '\x5a', '\xe2', '\xbf', '\xd2', '\xe4', '\x9c',
+ '\xb4', '\x34', '\x38', '\x97', '\x5e', '\x4d', '\x5e', '\x8a', '\x0b',
+ '\xd8', '\x42', '\x11', '\x88', '\x19', '\xa2', '\x23', '\x4b', '\xec',
+ '\x3b', '\x0a', '\xc9', '\x67', '\x49', '\x2c', '\x8e', '\x1c', '\x5e',
+ '\x7f', '\x42', '\xe7', '\x73', '\x0b', '\x86', '\x68', '\xf0', '\xaa',
+ '\x3f', '\x1e', '\x17', '\x3e', '\x29', '\xc4', '\x57', '\x6e', '\x34',
+ '\x78', '\xaf', '\x15', '\x03', '\x39', '\x32', '\x27', '\x80', '\x76',
+ '\xb1', '\xda', '\x08', '\xe5', '\x4d', '\x3f', '\x4c', '\xfc', '\x1e',
+ '\x23', '\x5a', '\xb3', '\xd4', '\x99', '\xdc', '\x5c', '\x2b', '\xf1',
+ '\xa8', '\xe3', '\x02', '\x0a', '\xc8', '\x4d', '\x63', '\x27', '\xb9',
+ '\x0d', '\x6c', '\xc2', '\x34', '\x82', '\x82', '\x5d', '\x56', '\xa8',
+ '\x93', '\x44', '\x8b', '\xf4', '\x8b', '\xf0', '\x63', '\xe5', '\x23',
+ '\x7f', '\x8d', '\x5f', '\x3a', '\x4a', '\xa5', '\x50', '\xb9', '\xc6',
+ '\x5c', '\xe6', '\x33', '\xe3', '\xfc', '\xc8', '\x96', '\x88', '\x88',
+ '\xe9', '\x53', '\xaf', '\x0d', '\xbb', '\x80', '\x9c', '\xbb', '\xed',
+ '\x4d', '\x06', '\xfa', '\xe9', '\x7c', '\x25', '\x1c', '\x59', '\xee',
+ '\x19', '\xcc', '\xa9', '\x7c', '\x1d', '\x86', '\xd9', '\x95', '\x78',
+ '\x2d', '\x3a', '\x95', '\x49', '\x11', '\x45', '\xfa', '\xd6', '\xef',
+ '\xd5', '\x07', '\x1c', '\x23', '\xeb', '\xad', '\xd3', '\x3b', '\x95',
+ '\xcf', '\x53', '\xa3', '\x47', '\xa9', '\xa7', '\x90', '\xde', '\x34',
+ '\xa4', '\xbb', '\x05', '\xdc', '\x54', '\x87', '\x97', '\x30', '\xea',
+ '\x25', '\xf0', '\xfd', '\xba', '\xa1', '\x1b', '\x02', '\x03', '\x01',
+ '\x00', '\x01', '\xa3', '\x81', '\x88', '\x30', '\x81', '\x85', '\x30',
+ '\x1d', '\x06', '\x03', '\x55', '\x1d', '\x0e', '\x04', '\x16', '\x04',
+ '\x14', '\x09', '\xfb', '\x77', '\xbb', '\xc8', '\x8f', '\xd6', '\xa4',
+ '\xf0', '\x74', '\xb2', '\x90', '\x46', '\x0a', '\x8d', '\x09', '\x4b',
+ '\x89', '\x2e', '\x41', '\x30', '\x1f', '\x06', '\x03', '\x55', '\x1d',
+ '\x23', '\x04', '\x18', '\x30', '\x16', '\x80', '\x14', '\x09', '\xfb',
+ '\x77', '\xbb', '\xc8', '\x8f', '\xd6', '\xa4', '\xf0', '\x74', '\xb2',
+ '\x90', '\x46', '\x0a', '\x8d', '\x09', '\x4b', '\x89', '\x2e', '\x41',
+ '\x30', '\x0f', '\x06', '\x03', '\x55', '\x1d', '\x13', '\x01', '\x01',
+ '\xff', '\x04', '\x05', '\x30', '\x03', '\x01', '\x01', '\xff', '\x30',
+ '\x32', '\x06', '\x03', '\x55', '\x1d', '\x11', '\x04', '\x2b', '\x30',
+ '\x29', '\x82', '\x08', '\x66', '\x6f', '\x6f', '\x2e', '\x74', '\x65',
+ '\x73', '\x74', '\x82', '\x0c', '\x77', '\x77', '\x77', '\x2e', '\x66',
+ '\x6f', '\x6f', '\x2e', '\x74', '\x65', '\x73', '\x74', '\x82', '\x0f',
+ '\x2a', '\x2e', '\x77', '\x69', '\x6c', '\x64', '\x63', '\x61', '\x72',
+ '\x64', '\x2e', '\x74', '\x65', '\x73', '\x74', '\x30', '\x0d', '\x06',
+ '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7', '\x0d', '\x01', '\x01',
+ '\x0b', '\x05', '\x00', '\x03', '\x82', '\x01', '\x01', '\x00', '\x93',
+ '\xbc', '\x33', '\x4c', '\xa4', '\xdf', '\xdc', '\xed', '\x4b', '\x4d',
+ '\x5e', '\xdb', '\xdd', '\x4a', '\xb7', '\xbc', '\x50', '\x1f', '\xca',
+ '\x66', '\x4d', '\x28', '\x96', '\x42', '\x4e', '\x84', '\x44', '\x80',
+ '\x25', '\x17', '\x2c', '\x05', '\x93', '\xe0', '\x2a', '\x29', '\xef',
+ '\xe4', '\x26', '\x19', '\x63', '\xdf', '\xb2', '\x72', '\xb1', '\x82',
+ '\x7e', '\x5f', '\xce', '\x82', '\x41', '\xad', '\x96', '\x78', '\x94',
+ '\xa8', '\x21', '\xee', '\xf2', '\x4a', '\xf5', '\x41', '\xa8', '\xfb',
+ '\xe0', '\xe1', '\x22', '\x89', '\xf1', '\x40', '\x85', '\x86', '\x53',
+ '\x61', '\x57', '\x0f', '\x31', '\xae', '\x0c', '\xc3', '\x8d', '\xe8',
+ '\x29', '\xac', '\xe0', '\x03', '\x2d', '\x69', '\x44', '\x3d', '\xd6',
+ '\x3b', '\x2b', '\x0f', '\xb3', '\xf5', '\x83', '\x1b', '\x4e', '\x65',
+ '\x60', '\x6b', '\xa2', '\x01', '\x03', '\x1e', '\x98', '\xca', '\xca',
+ '\x32', '\xd4', '\x5b', '\xde', '\x45', '\xe2', '\x35', '\xd2', '\x54',
+ '\x1a', '\x2a', '\x38', '\xa7', '\x42', '\xa0', '\xf3', '\xef', '\x28',
+ '\xe3', '\x6e', '\x23', '\x77', '\x07', '\xd5', '\xef', '\xfd', '\x30',
+ '\xd6', '\x31', '\xfa', '\xf2', '\x94', '\x95', '\x2f', '\x03', '\x7a',
+ '\x43', '\xe0', '\xb3', '\x82', '\xca', '\x7e', '\xb4', '\x00', '\xc9',
+ '\x08', '\x15', '\x7b', '\x2e', '\x51', '\xec', '\xab', '\x68', '\xca',
+ '\xc2', '\xca', '\x44', '\xe1', '\xbe', '\xe4', '\x06', '\x98', '\x87',
+ '\x9b', '\x58', '\xbc', '\xf1', '\xea', '\x55', '\xf6', '\x64', '\x92',
+ '\xe6', '\x73', '\xc9', '\xf6', '\xc5', '\x7a', '\x90', '\x42', '\x83',
+ '\x39', '\x9e', '\xd0', '\xca', '\x85', '\x6c', '\x53', '\x99', '\x64',
+ '\xbb', '\x49', '\xdc', '\xae', '\x1c', '\xe5', '\x00', '\x65', '\x13',
+ '\xdd', '\xdc', '\xde', '\x3f', '\xf9', '\x14', '\x91', '\x0d', '\xe6',
+ '\xba', '\xc1', '\x7d', '\x5f', '\xd5', '\x6d', '\xe8', '\x65', '\x9c',
+ '\xfb', '\xda', '\x82', '\xf7', '\x4d', '\x45', '\x81', '\x8c', '\x54',
+ '\xec', '\x50', '\xbb', '\x14', '\xe9', '\x06', '\xda', '\x76', '\xb3',
+ '\xf0', '\xb7', '\xbb', '\x58', '\x4c', '\x8f', '\x6a', '\x5d', '\x8e',
+ '\x93', '\x5f', '\x35'};
+
+ABSL_CONST_INIT const absl::string_view kWildcardCertificate(
+ kWildcardCertificateRaw,
+ sizeof(kWildcardCertificateRaw));
+
+ABSL_CONST_INIT const char kWildcardCertificatePrivateKeyRaw[] = {
+ '\x30', '\x82', '\x04', '\xbe', '\x02', '\x01', '\x00', '\x30', '\x0d',
+ '\x06', '\x09', '\x2a', '\x86', '\x48', '\x86', '\xf7', '\x0d', '\x01',
+ '\x01', '\x01', '\x05', '\x00', '\x04', '\x82', '\x04', '\xa8', '\x30',
+ '\x82', '\x04', '\xa4', '\x02', '\x01', '\x00', '\x02', '\x82', '\x01',
+ '\x01', '\x00', '\xcc', '\xd5', '\x5d', '\xa0', '\x4a', '\x03', '\x9d',
+ '\x89', '\xa2', '\xae', '\x7a', '\x59', '\x15', '\xf7', '\x27', '\x67',
+ '\x49', '\xa4', '\xc1', '\x87', '\xcd', '\x9c', '\x02', '\x9e', '\xb9',
+ '\x2f', '\xd1', '\xa1', '\x0d', '\x57', '\xff', '\xd6', '\xc0', '\x6a',
+ '\x7b', '\xaa', '\x52', '\xb2', '\x6e', '\xa6', '\x12', '\x34', '\xcf',
+ '\xdc', '\xd3', '\x1e', '\x32', '\xc1', '\x8d', '\x42', '\xa3', '\x0b',
+ '\xd6', '\xaf', '\xe9', '\x37', '\x42', '\xf8', '\x78', '\xdc', '\xcb',
+ '\x2d', '\x0e', '\x42', '\x5a', '\xe2', '\xbf', '\xd2', '\xe4', '\x9c',
+ '\xb4', '\x34', '\x38', '\x97', '\x5e', '\x4d', '\x5e', '\x8a', '\x0b',
+ '\xd8', '\x42', '\x11', '\x88', '\x19', '\xa2', '\x23', '\x4b', '\xec',
+ '\x3b', '\x0a', '\xc9', '\x67', '\x49', '\x2c', '\x8e', '\x1c', '\x5e',
+ '\x7f', '\x42', '\xe7', '\x73', '\x0b', '\x86', '\x68', '\xf0', '\xaa',
+ '\x3f', '\x1e', '\x17', '\x3e', '\x29', '\xc4', '\x57', '\x6e', '\x34',
+ '\x78', '\xaf', '\x15', '\x03', '\x39', '\x32', '\x27', '\x80', '\x76',
+ '\xb1', '\xda', '\x08', '\xe5', '\x4d', '\x3f', '\x4c', '\xfc', '\x1e',
+ '\x23', '\x5a', '\xb3', '\xd4', '\x99', '\xdc', '\x5c', '\x2b', '\xf1',
+ '\xa8', '\xe3', '\x02', '\x0a', '\xc8', '\x4d', '\x63', '\x27', '\xb9',
+ '\x0d', '\x6c', '\xc2', '\x34', '\x82', '\x82', '\x5d', '\x56', '\xa8',
+ '\x93', '\x44', '\x8b', '\xf4', '\x8b', '\xf0', '\x63', '\xe5', '\x23',
+ '\x7f', '\x8d', '\x5f', '\x3a', '\x4a', '\xa5', '\x50', '\xb9', '\xc6',
+ '\x5c', '\xe6', '\x33', '\xe3', '\xfc', '\xc8', '\x96', '\x88', '\x88',
+ '\xe9', '\x53', '\xaf', '\x0d', '\xbb', '\x80', '\x9c', '\xbb', '\xed',
+ '\x4d', '\x06', '\xfa', '\xe9', '\x7c', '\x25', '\x1c', '\x59', '\xee',
+ '\x19', '\xcc', '\xa9', '\x7c', '\x1d', '\x86', '\xd9', '\x95', '\x78',
+ '\x2d', '\x3a', '\x95', '\x49', '\x11', '\x45', '\xfa', '\xd6', '\xef',
+ '\xd5', '\x07', '\x1c', '\x23', '\xeb', '\xad', '\xd3', '\x3b', '\x95',
+ '\xcf', '\x53', '\xa3', '\x47', '\xa9', '\xa7', '\x90', '\xde', '\x34',
+ '\xa4', '\xbb', '\x05', '\xdc', '\x54', '\x87', '\x97', '\x30', '\xea',
+ '\x25', '\xf0', '\xfd', '\xba', '\xa1', '\x1b', '\x02', '\x03', '\x01',
+ '\x00', '\x01', '\x02', '\x82', '\x01', '\x01', '\x00', '\xa3', '\xb3',
+ '\x01', '\x98', '\x50', '\x8e', '\x83', '\x20', '\xb4', '\x3a', '\xec',
+ '\xdc', '\xb5', '\x89', '\x48', '\x9c', '\x6b', '\x66', '\x98', '\xa4',
+ '\x87', '\xd5', '\xde', '\xe2', '\x2a', '\xed', '\xe4', '\x82', '\xe9',
+ '\xbf', '\x22', '\x5f', '\xe6', '\x77', '\x33', '\x4d', '\xf3', '\xb9',
+ '\x56', '\x64', '\xb2', '\xb8', '\x32', '\x47', '\x31', '\x12', '\x39',
+ '\x4e', '\x26', '\x2e', '\xd3', '\x4f', '\x6a', '\xcc', '\x3b', '\x7e',
+ '\x46', '\xaf', '\x7d', '\x28', '\x37', '\xd8', '\x52', '\x45', '\x05',
+ '\x8d', '\xa1', '\xf0', '\x51', '\x74', '\x4b', '\x30', '\x50', '\xe9',
+ '\xe8', '\x1b', '\xbd', '\x2a', '\x66', '\x3c', '\xf6', '\xd0', '\x3c',
+ '\x0d', '\x00', '\x5f', '\x65', '\x15', '\xee', '\x39', '\xb8', '\xac',
+ '\x2a', '\xf6', '\xc8', '\xbc', '\x33', '\x69', '\x51', '\x76', '\xd7',
+ '\xa2', '\xa6', '\x50', '\xc7', '\xc5', '\xc7', '\x9b', '\xac', '\xc7',
+ '\xa9', '\x69', '\x98', '\xd6', '\x22', '\x69', '\x30', '\xc3', '\x82',
+ '\x47', '\xfb', '\xa5', '\x46', '\x2d', '\x96', '\x05', '\xc2', '\x84',
+ '\xd1', '\x1d', '\xd5', '\xa7', '\x5c', '\xdb', '\x6d', '\x35', '\x7b',
+ '\x1b', '\x80', '\xe4', '\x42', '\x1f', '\x4d', '\x68', '\x2e', '\xbc',
+ '\x58', '\xb6', '\x7c', '\x7e', '\xc5', '\x07', '\xe1', '\xf5', '\x30',
+ '\xa9', '\x8f', '\x14', '\x76', '\xad', '\xe2', '\xdf', '\xaf', '\xd3',
+ '\xf1', '\xba', '\xd5', '\x98', '\xf3', '\x5e', '\x30', '\x79', '\xcb',
+ '\xe7', '\x7a', '\x83', '\xba', '\xf7', '\x71', '\xb0', '\xb2', '\xd1',
+ '\xf4', '\x34', '\x5b', '\xe1', '\xe8', '\x60', '\x39', '\x96', '\x12',
+ '\xdc', '\xb4', '\x0d', '\xf9', '\x8d', '\x8c', '\xd8', '\xbb', '\xb7',
+ '\xd2', '\x1b', '\x83', '\x10', '\xbd', '\x86', '\xef', '\x5c', '\x6c',
+ '\xe3', '\xb1', '\x96', '\x7f', '\xab', '\x58', '\xce', '\x87', '\xc9',
+ '\x48', '\x69', '\xbb', '\xb1', '\xec', '\xa4', '\x3a', '\x06', '\xa3',
+ '\x33', '\xad', '\x7a', '\xe5', '\x88', '\x6d', '\x32', '\x67', '\x1c',
+ '\x03', '\xda', '\x9d', '\x3c', '\x73', '\xe0', '\xd7', '\x6c', '\x00',
+ '\xe4', '\x8d', '\x7d', '\xf2', '\xac', '\xa5', '\xb8', '\x35', '\xb9',
+ '\xac', '\x81', '\x02', '\x81', '\x81', '\x00', '\xe8', '\xd5', '\x5b',
+ '\xd0', '\x4f', '\x7c', '\xfc', '\x4b', '\xe6', '\xe8', '\x3c', '\x4c',
+ '\x24', '\xce', '\x68', '\x73', '\x3b', '\x4b', '\xa0', '\xfb', '\x79',
+ '\xa5', '\x72', '\x1d', '\x77', '\xb2', '\xdf', '\x2b', '\x0a', '\x11',
+ '\x28', '\xe8', '\x02', '\x7f', '\x26', '\x40', '\x34', '\x8f', '\x78',
+ '\x18', '\xad', '\xf4', '\x11', '\x78', '\x45', '\x9f', '\x66', '\x4e',
+ '\x78', '\x71', '\x60', '\x40', '\xeb', '\x64', '\x28', '\x06', '\xae',
+ '\x9b', '\x32', '\x73', '\xb5', '\xe1', '\x7e', '\x3c', '\x07', '\x31',
+ '\x8d', '\x82', '\xed', '\x6a', '\xe6', '\x1e', '\x65', '\x9e', '\x81',
+ '\x29', '\x08', '\x56', '\x17', '\x4b', '\x31', '\xc3', '\xf5', '\x27',
+ '\xef', '\xb8', '\xda', '\x58', '\xff', '\x36', '\x47', '\x12', '\xb0',
+ '\xef', '\x14', '\x20', '\x5c', '\x48', '\xb3', '\x84', '\x0d', '\x64',
+ '\x22', '\x3e', '\xfe', '\x94', '\x17', '\x6c', '\x45', '\xe7', '\x3f',
+ '\x4c', '\x90', '\x67', '\x13', '\x1a', '\xa8', '\xbc', '\x5b', '\xd0',
+ '\xc1', '\x8a', '\xa9', '\x42', '\xbe', '\xe4', '\x0e', '\x59', '\x02',
+ '\x81', '\x81', '\x00', '\xe1', '\x36', '\xcd', '\x86', '\x1e', '\xcb',
+ '\x8b', '\x68', '\x65', '\x6b', '\x42', '\xec', '\x50', '\x29', '\xa0',
+ '\xab', '\x3a', '\xe5', '\x6f', '\xe1', '\x13', '\xe8', '\xa3', '\x6b',
+ '\x7c', '\x2b', '\xd3', '\x69', '\x89', '\x47', '\x07', '\x39', '\xb2',
+ '\x0f', '\x03', '\x4e', '\x6f', '\x28', '\x94', '\x1d', '\x1f', '\x22',
+ '\x47', '\xf9', '\x95', '\xff', '\x3e', '\xa4', '\x26', '\x38', '\x07',
+ '\x5b', '\xdd', '\xef', '\x0a', '\xa5', '\xe8', '\x99', '\xad', '\x91',
+ '\x68', '\x83', '\xf2', '\xf5', '\xa5', '\x3d', '\x21', '\x88', '\xa5',
+ '\x6a', '\x39', '\x3b', '\xca', '\x4c', '\xc9', '\xd1', '\x9a', '\x74',
+ '\xb2', '\xe3', '\x73', '\x5d', '\xfe', '\xbd', '\x05', '\x1b', '\x9a',
+ '\x13', '\x98', '\x39', '\x93', '\xf3', '\x88', '\x55', '\x61', '\x85',
+ '\x7a', '\x53', '\x5a', '\xd9', '\x2c', '\xdb', '\x15', '\x69', '\xa6',
+ '\x31', '\x09', '\xbb', '\xd1', '\xe8', '\x6e', '\x8c', '\x47', '\x77',
+ '\x1e', '\x9b', '\xbe', '\xb7', '\x57', '\xd4', '\xaa', '\xd5', '\x92',
+ '\xa1', '\xd5', '\x55', '\x04', '\x93', '\x02', '\x81', '\x80', '\x06',
+ '\x84', '\x01', '\xff', '\xc0', '\x59', '\xb5', '\x0d', '\xc2', '\xb6',
+ '\x79', '\x09', '\x80', '\x76', '\x2e', '\x42', '\x1b', '\x44', '\xb0',
+ '\x8a', '\x99', '\x0a', '\xe2', '\x38', '\xa4', '\xe2', '\xe2', '\x8f',
+ '\xe7', '\xc6', '\x37', '\x28', '\xd6', '\xf9', '\x0b', '\xee', '\xfc',
+ '\x09', '\x8f', '\xc8', '\xd1', '\x05', '\x65', '\x7f', '\xc2', '\x23',
+ '\x05', '\xcf', '\xe8', '\x5a', '\xf3', '\xe0', '\x9d', '\x35', '\xbe',
+ '\x51', '\x01', '\x8d', '\xe2', '\x49', '\x8e', '\xab', '\x72', '\xc6',
+ '\xe7', '\x44', '\xa1', '\xbb', '\x2a', '\x3d', '\xb5', '\x96', '\xe0',
+ '\x2d', '\x21', '\x5c', '\x2e', '\x99', '\x8a', '\x29', '\x56', '\x89',
+ '\x2f', '\x51', '\x20', '\xca', '\x41', '\x82', '\x00', '\x12', '\x5a',
+ '\xc6', '\xd1', '\x20', '\xbf', '\xa5', '\x70', '\x2f', '\xb0', '\xa6',
+ '\x5f', '\x61', '\x8f', '\xfb', '\xc7', '\x50', '\x09', '\x9f', '\xc4',
+ '\x0d', '\x06', '\x9e', '\x73', '\xe4', '\x0e', '\x8a', '\xce', '\x72',
+ '\x06', '\xf7', '\xbe', '\x92', '\xcc', '\xcd', '\xcb', '\x5d', '\xc2',
+ '\x71', '\x02', '\x81', '\x80', '\x26', '\xf3', '\xba', '\x92', '\x52',
+ '\xeb', '\x33', '\x7e', '\x67', '\xe4', '\x28', '\x5c', '\x04', '\xf5',
+ '\x5e', '\x33', '\x9f', '\x69', '\x25', '\x73', '\x91', '\x64', '\xf0',
+ '\x36', '\xdb', '\xf0', '\x1c', '\x8d', '\xa9', '\x4f', '\x9e', '\xa1',
+ '\x4c', '\xf9', '\xa9', '\xc1', '\xbc', '\x1a', '\x11', '\x9c', '\x03',
+ '\xd1', '\x83', '\x0f', '\x58', '\xf1', '\x1f', '\x9d', '\x76', '\x7a',
+ '\xc4', '\x53', '\x10', '\x4c', '\x92', '\xd3', '\xe5', '\x2a', '\x07',
+ '\x4a', '\x1a', '\x00', '\x90', '\x5a', '\x0a', '\x2d', '\x4b', '\x8a',
+ '\x7d', '\xc9', '\xa4', '\x82', '\x81', '\xd7', '\xcc', '\x24', '\x33',
+ '\x89', '\xb1', '\x93', '\x03', '\x56', '\x23', '\x83', '\xff', '\xc9',
+ '\x29', '\x59', '\xf0', '\x3f', '\x2d', '\x26', '\xb6', '\xd2', '\xc5',
+ '\x9e', '\x37', '\x6d', '\x09', '\x4e', '\x7c', '\xa2', '\x9b', '\xce',
+ '\x7d', '\x0f', '\x08', '\x36', '\xf2', '\xf4', '\x37', '\x82', '\x8d',
+ '\xad', '\xbd', '\x9e', '\x84', '\x5a', '\xe3', '\x97', '\x05', '\xc1',
+ '\x10', '\xae', '\x6a', '\xde', '\x5c', '\x7f', '\x02', '\x81', '\x81',
+ '\x00', '\x9b', '\x8e', '\xa4', '\x2b', '\xcf', '\xb6', '\x30', '\x1c',
+ '\xb5', '\x82', '\x50', '\x08', '\xc0', '\x0b', '\x57', '\xf4', '\x2d',
+ '\x82', '\x39', '\x11', '\x1b', '\x02', '\xe6', '\xbe', '\x14', '\x26',
+ '\x77', '\xd7', '\x26', '\x1f', '\x0d', '\x92', '\xc6', '\x67', '\xa0',
+ '\x01', '\x6c', '\xd9', '\x7a', '\xdf', '\xc3', '\x3d', '\x50', '\x8d',
+ '\x43', '\xef', '\x95', '\x50', '\x72', '\x25', '\x06', '\x28', '\x7a',
+ '\x7e', '\x99', '\xea', '\x4d', '\xe8', '\x87', '\xe5', '\xca', '\x71',
+ '\x36', '\x8a', '\xce', '\x18', '\x55', '\xe4', '\x87', '\x39', '\x3d',
+ '\xea', '\x9a', '\x22', '\x99', '\x1a', '\xab', '\xe3', '\x6f', '\x48',
+ '\x78', '\x49', '\x8f', '\xf6', '\xfa', '\xb1', '\xb8', '\x68', '\xae',
+ '\xc3', '\x47', '\x1d', '\x8f', '\x1d', '\x11', '\xa1', '\x06', '\xf5',
+ '\xc0', '\x0d', '\xcf', '\x7b', '\x33', '\xfe', '\x0c', '\x69', '\xca',
+ '\x46', '\xfe', '\x2c', '\xac', '\xd8', '\x4d', '\x02', '\x79', '\xfe',
+ '\x47', '\xca', '\x21', '\x30', '\x65', '\xa4', '\xe5', '\xaa', '\x4e',
+ '\x9c', '\xbc', '\xa5'};
+
+ABSL_CONST_INIT const absl::string_view kWildcardCertificatePrivateKey(
+ kWildcardCertificatePrivateKeyRaw,
+ sizeof(kWildcardCertificatePrivateKeyRaw));
+
+ABSL_CONST_INIT const char kTestEcPrivateKeyLegacyPem[] =
+ R"(-----BEGIN EC PARAMETERS-----
+BggqhkjOPQMBBw==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIMdjXX0hg399DlccZuYFXPKq+dMGduXWmQYClDYJNDGroAoGCCqGSM49
+AwEHoUQDQgAENCuPQTywFI8hbsGo68AeN1KVWmd09buzlu/2CAtsJcNoECUmpVXH
+4dwvWMv6zWn9RJ5EzI72R/5FVcO485s5MQ==
+-----END EC PRIVATE KEY-----)";
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/test_certificates.h b/quiche/quic/test_tools/test_certificates.h
new file mode 100644
index 0000000..6a7eba7
--- /dev/null
+++ b/quiche/quic/test_tools/test_certificates.h
@@ -0,0 +1,50 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_TEST_CERTIFICATES_H_
+#define QUICHE_QUIC_TEST_TOOLS_TEST_CERTIFICATES_H_
+
+#include "absl/base/attributes.h"
+#include "absl/strings/string_view.h"
+
+namespace quic {
+namespace test {
+
+// A test certificate generated by //net/tools/quic/certs/generate-certs.sh.
+ABSL_CONST_INIT extern const absl::string_view kTestCertificate;
+
+// PEM-encoded version of |kTestCertificate|.
+ABSL_CONST_INIT extern const char kTestCertificatePem[];
+
+// |kTestCertificatePem| with a PEM-encoded root appended to the end.
+ABSL_CONST_INIT extern const char kTestCertificateChainPem[];
+
+// PEM-encoded certificate that contains a subjectAltName with an
+// unknown/unsupported type.
+ABSL_CONST_INIT extern const char kTestCertWithUnknownSanTypePem[];
+
+// DER-encoded private key for |kTestCertificate|.
+ABSL_CONST_INIT extern const absl::string_view kTestCertificatePrivateKey;
+
+// PEM-encoded version of |kTestCertificatePrivateKey|.
+ABSL_CONST_INIT extern const char kTestCertificatePrivateKeyPem[];
+
+// The legacy PEM-encoded version of |kTestCertificatePrivateKey| manually
+// generated from the one above using der2ascii.
+ABSL_CONST_INIT extern const char kTestCertificatePrivateKeyLegacyPem[];
+
+// Another DER-encoded test certificate, valid for foo.test, www.foo.test and
+// *.wildcard.test.
+ABSL_CONST_INIT extern const absl::string_view kWildcardCertificate;
+
+// DER-encoded private key for |kWildcardCertificate|.
+ABSL_CONST_INIT extern const absl::string_view kWildcardCertificatePrivateKey;
+
+// PEM-encoded P-256 private key using legacy OpenSSL encoding.
+ABSL_CONST_INIT extern const char kTestEcPrivateKeyLegacyPem[];
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_TEST_CERTIFICATES_H_
diff --git a/quiche/quic/test_tools/test_ticket_crypter.cc b/quiche/quic/test_tools/test_ticket_crypter.cc
new file mode 100644
index 0000000..7c4a54e
--- /dev/null
+++ b/quiche/quic/test_tools/test_ticket_crypter.cc
@@ -0,0 +1,83 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/test_ticket_crypter.h"
+
+#include <cstring>
+
+#include "absl/base/macros.h"
+#include "quiche/quic/core/crypto/quic_random.h"
+
+namespace quic {
+namespace test {
+
+namespace {
+
+// A TicketCrypter implementation is supposed to encrypt and decrypt session
+// tickets. However, the only requirement that is needed of a test
+// implementation is that calling Decrypt(Encrypt(input), callback) results in
+// callback being called with input. (The output of Encrypt must also not exceed
+// the overhead specified by MaxOverhead.) This test implementation encrypts
+// tickets by prepending kTicketPrefix to generate the ciphertext. The decrypt
+// function checks that the prefix is present and strips it; otherwise it
+// returns an empty vector to signal failure.
+constexpr char kTicketPrefix[] = "TEST TICKET";
+
+} // namespace
+
+TestTicketCrypter::TestTicketCrypter()
+ : ticket_prefix_(ABSL_ARRAYSIZE(kTicketPrefix) + 16) {
+ memcpy(ticket_prefix_.data(), kTicketPrefix, ABSL_ARRAYSIZE(kTicketPrefix));
+ QuicRandom::GetInstance()->RandBytes(
+ ticket_prefix_.data() + ABSL_ARRAYSIZE(kTicketPrefix), 16);
+}
+
+size_t TestTicketCrypter::MaxOverhead() {
+ return ticket_prefix_.size();
+}
+
+std::vector<uint8_t> TestTicketCrypter::Encrypt(
+ absl::string_view in, absl::string_view /* encryption_key */) {
+ size_t prefix_len = ticket_prefix_.size();
+ std::vector<uint8_t> out(prefix_len + in.size());
+ memcpy(out.data(), ticket_prefix_.data(), prefix_len);
+ memcpy(out.data() + prefix_len, in.data(), in.size());
+ return out;
+}
+
+std::vector<uint8_t> TestTicketCrypter::Decrypt(absl::string_view in) {
+ size_t prefix_len = ticket_prefix_.size();
+ if (fail_decrypt_ || in.size() < prefix_len ||
+ memcmp(ticket_prefix_.data(), in.data(), prefix_len) != 0) {
+ return std::vector<uint8_t>();
+ }
+ return std::vector<uint8_t>(in.begin() + prefix_len, in.end());
+}
+
+void TestTicketCrypter::Decrypt(
+ absl::string_view in,
+ std::unique_ptr<ProofSource::DecryptCallback> callback) {
+ auto decrypted_ticket = Decrypt(in);
+ if (run_async_) {
+ pending_callbacks_.push_back({std::move(callback), decrypted_ticket});
+ } else {
+ callback->Run(decrypted_ticket);
+ }
+}
+
+void TestTicketCrypter::SetRunCallbacksAsync(bool run_async) {
+ run_async_ = run_async;
+}
+
+size_t TestTicketCrypter::NumPendingCallbacks() {
+ return pending_callbacks_.size();
+}
+
+void TestTicketCrypter::RunPendingCallback(size_t n) {
+ const PendingCallback& callback = pending_callbacks_[n];
+ callback.callback->Run(callback.decrypted_ticket);
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/test_ticket_crypter.h b/quiche/quic/test_tools/test_ticket_crypter.h
new file mode 100644
index 0000000..8443099
--- /dev/null
+++ b/quiche/quic/test_tools/test_ticket_crypter.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_TEST_TICKET_CRYPTER_H_
+#define QUICHE_QUIC_TEST_TOOLS_TEST_TICKET_CRYPTER_H_
+
+#include "quiche/quic/core/crypto/proof_source.h"
+
+namespace quic {
+namespace test {
+
+// Provides a simple implementation of ProofSource::TicketCrypter for testing.
+// THIS IMPLEMENTATION IS NOT SECURE. It is only intended for testing purposes.
+class TestTicketCrypter : public ProofSource::TicketCrypter {
+ public:
+ TestTicketCrypter();
+ ~TestTicketCrypter() override = default;
+
+ // TicketCrypter interface
+ size_t MaxOverhead() override;
+ std::vector<uint8_t> Encrypt(absl::string_view in,
+ absl::string_view encryption_key) override;
+ void Decrypt(absl::string_view in,
+ std::unique_ptr<ProofSource::DecryptCallback> callback) override;
+
+ void SetRunCallbacksAsync(bool run_async);
+ size_t NumPendingCallbacks();
+ void RunPendingCallback(size_t n);
+
+ // Allows configuring this TestTicketCrypter to fail decryption.
+ void set_fail_decrypt(bool fail_decrypt) { fail_decrypt_ = fail_decrypt; }
+
+ private:
+ // Performs the Decrypt operation synchronously.
+ std::vector<uint8_t> Decrypt(absl::string_view in);
+
+ struct PendingCallback {
+ std::unique_ptr<ProofSource::DecryptCallback> callback;
+ std::vector<uint8_t> decrypted_ticket;
+ };
+
+ bool fail_decrypt_ = false;
+ bool run_async_ = false;
+ std::vector<PendingCallback> pending_callbacks_;
+ std::vector<uint8_t> ticket_prefix_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_TEST_TICKET_CRYPTER_H_
diff --git a/quiche/quic/test_tools/web_transport_resets_backend.cc b/quiche/quic/test_tools/web_transport_resets_backend.cc
new file mode 100644
index 0000000..aa48dd6
--- /dev/null
+++ b/quiche/quic/test_tools/web_transport_resets_backend.cc
@@ -0,0 +1,113 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/web_transport_resets_backend.h"
+
+#include <memory>
+
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/tools/web_transport_test_visitors.h"
+#include "quiche/common/quiche_circular_deque.h"
+
+namespace quic {
+namespace test {
+
+namespace {
+
+class ResetsVisitor;
+
+class BidirectionalEchoVisitorWithLogging
+ : public WebTransportBidirectionalEchoVisitor {
+ public:
+ BidirectionalEchoVisitorWithLogging(WebTransportStream* stream,
+ ResetsVisitor* session_visitor)
+ : WebTransportBidirectionalEchoVisitor(stream),
+ session_visitor_(session_visitor) {}
+
+ void OnResetStreamReceived(WebTransportStreamError error) override;
+ void OnStopSendingReceived(WebTransportStreamError error) override;
+
+ private:
+ ResetsVisitor* session_visitor_; // Not owned.
+};
+
+class ResetsVisitor : public WebTransportVisitor {
+ public:
+ ResetsVisitor(WebTransportSession* session) : session_(session) {}
+
+ void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+ void OnSessionClosed(WebTransportSessionError /*error_code*/,
+ const std::string& /*error_message*/) override {}
+
+ void OnIncomingBidirectionalStreamAvailable() override {
+ while (true) {
+ WebTransportStream* stream =
+ session_->AcceptIncomingBidirectionalStream();
+ if (stream == nullptr) {
+ return;
+ }
+ stream->SetVisitor(
+ std::make_unique<BidirectionalEchoVisitorWithLogging>(stream, this));
+ stream->visitor()->OnCanRead();
+ }
+ }
+ void OnIncomingUnidirectionalStreamAvailable() override {}
+
+ void OnDatagramReceived(absl::string_view /*datagram*/) override {}
+
+ void OnCanCreateNewOutgoingBidirectionalStream() override {}
+ void OnCanCreateNewOutgoingUnidirectionalStream() override {
+ MaybeSendLogsBack();
+ }
+
+ void Log(std::string line) {
+ log_.push_back(std::move(line));
+ MaybeSendLogsBack();
+ }
+
+ private:
+ void MaybeSendLogsBack() {
+ while (!log_.empty() &&
+ session_->CanOpenNextOutgoingUnidirectionalStream()) {
+ WebTransportStream* stream = session_->OpenOutgoingUnidirectionalStream();
+ stream->SetVisitor(
+ std::make_unique<WebTransportUnidirectionalEchoWriteVisitor>(
+ stream, log_.front()));
+ log_.pop_front();
+ stream->visitor()->OnCanWrite();
+ }
+ }
+
+ WebTransportSession* session_; // Not owned.
+ quiche::QuicheCircularDeque<std::string> log_;
+};
+
+void BidirectionalEchoVisitorWithLogging::OnResetStreamReceived(
+ WebTransportStreamError error) {
+ session_visitor_->Log(absl::StrCat("Received reset for stream ",
+ stream()->GetStreamId(),
+ " with error code ", error));
+ WebTransportBidirectionalEchoVisitor::OnResetStreamReceived(error);
+}
+void BidirectionalEchoVisitorWithLogging::OnStopSendingReceived(
+ WebTransportStreamError error) {
+ session_visitor_->Log(absl::StrCat("Received stop sending for stream ",
+ stream()->GetStreamId(),
+ " with error code ", error));
+ WebTransportBidirectionalEchoVisitor::OnStopSendingReceived(error);
+}
+
+} // namespace
+
+QuicSimpleServerBackend::WebTransportResponse WebTransportResetsBackend(
+ const spdy::Http2HeaderBlock& /*request_headers*/,
+ WebTransportSession* session) {
+ QuicSimpleServerBackend::WebTransportResponse response;
+ response.response_headers[":status"] = "200";
+ response.visitor = std::make_unique<ResetsVisitor>(session);
+ return response;
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quiche/quic/test_tools/web_transport_resets_backend.h b/quiche/quic/test_tools/web_transport_resets_backend.h
new file mode 100644
index 0000000..d3b490c
--- /dev/null
+++ b/quiche/quic/test_tools/web_transport_resets_backend.h
@@ -0,0 +1,23 @@
+// Copyright (c) 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
+#define QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
+
+#include "quiche/quic/test_tools/quic_test_backend.h"
+
+namespace quic {
+namespace test {
+
+// A backend for testing RESET_STREAM/STOP_SENDING behavior. Provides
+// bidirectional echo streams; whenever one of those receives RESET_STREAM or
+// STOP_SENDING, a log message is sent as a unidirectional stream.
+QuicSimpleServerBackend::WebTransportResponse WebTransportResetsBackend(
+ const spdy::Http2HeaderBlock& request_headers,
+ WebTransportSession* session);
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
