quic_socket_data_provider.cc | Explore in Territory

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/quic/quic_socket_data_provider.h"

#include <algorithm>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <sstream>
#include <string>

#include "base/functional/callback.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "net/base/hex_utils.h"
#include "net/socket/socket_test_util.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace net::test {

QuicSocketDataProvider::Expectation::Expectation(
    std::string name,
    Type type,
    int rv,
    std::unique_ptr<quic::QuicEncryptedPacket> packet)
    : … { … }

QuicSocketDataProvider::Expectation::Expectation(
    QuicSocketDataProvider::Expectation&&) = default;

QuicSocketDataProvider::Expectation::~Expectation() = default;

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::Expectation::After(
    std::string name) { … }

std::string QuicSocketDataProvider::Expectation::TypeToString(
    QuicSocketDataProvider::Expectation::Type type) { … }

void QuicSocketDataProvider::Expectation::Consume() { … }

QuicSocketDataProvider::QuicSocketDataProvider(quic::ParsedQuicVersion version)
    : … { … }

QuicSocketDataProvider::~QuicSocketDataProvider() = default;

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::AddRead(
    std::string name,
    std::unique_ptr<quic::QuicEncryptedPacket> packet) { … }

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::AddRead(
    std::string name,
    std::unique_ptr<quic::QuicReceivedPacket> packet) { … }

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::AddReadError(
    std::string name,
    int rv) { … }

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::AddWrite(
    std::string name,
    std::unique_ptr<quic::QuicEncryptedPacket> packet,
    int rv) { … }

QuicSocketDataProvider::Expectation& QuicSocketDataProvider::AddWriteError(
    std::string name,
    int rv) { … }

QuicSocketDataProvider::PausePoint QuicSocketDataProvider::AddPause(
    std::string name) { … }

bool QuicSocketDataProvider::AllDataConsumed() const { … }

void QuicSocketDataProvider::RunUntilPause(
    QuicSocketDataProvider::PausePoint pause_point) { … }

void QuicSocketDataProvider::Resume() { … }

void QuicSocketDataProvider::RunUntilAllConsumed() { … }

MockRead QuicSocketDataProvider::OnRead() { … }

MockWriteResult QuicSocketDataProvider::OnWrite(const std::string& data) { … }

bool QuicSocketDataProvider::AllReadDataConsumed() const { … }

bool QuicSocketDataProvider::AllWriteDataConsumed() const { … }

void QuicSocketDataProvider::CancelPendingRead() { … }

void QuicSocketDataProvider::Reset() { … }

std::optional<size_t> QuicSocketDataProvider::FindReadyExpectations(
    Expectation::Type type) { … }

std::optional<MockRead> QuicSocketDataProvider::ConsumeNextRead() { … }

std::optional<MockWriteResult> QuicSocketDataProvider::ConsumeNextWrite() { … }

void QuicSocketDataProvider::MaybeConsumeExpectations() { … }

void QuicSocketDataProvider::ExpectationConsumed() { … }

bool QuicSocketDataProvider::VerifyWriteData(
    QuicSocketDataProvider::Expectation& expectation) { … }

std::string QuicSocketDataProvider::ExpectationList(
    const std::vector<size_t>& indices) { … }

}  // namespace net::test
chromium/net/quic/quic_socket_data_provider.cc
