Files
aevolution/tests/quic_transport.cpp
dingoandClaude Opus 5.5 ada77fd761
Foundation / checks (deploy) (push) Successful in 3m24s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m18s
Foundation / checks (network) (push) Successful in 13m30s
Foundation / checks (tsan) (push) Successful in 8m0s
Foundation / checks (checks) (push) Successful in 32m39s
Foundation / checks (postgres) (push) Successful in 45m47s
Foundation / postgres-tools (push) Successful in 17s
Foundation / image (push) Successful in 2m30s
Foundation / server-image (push) Successful in 4m8s
Add M10.9d load drill harness and serialize Mbed TLS use
ADR-0097. tools/ops/load-drill.sh (runbook docs/networking/M10_LOAD_DRILL.md)
runs the evolution-dev reference qualification: synthetic inputs on for
the run (the ADR-0073 drill-time override, restored on exit), bundle-mode
evo-load bots through the public route, and each step's hold matched with
the server's reports. evo-server logs "m10 load-report" every 10 s, since
the agent cannot reach the ops port. evo-load gains --grants FILE
--grants-per-bot C, exhausted=, hold_utc= and close_reasons=;
evo-session-probe grants gains --accounts N.

Finding: Mbed TLS/PSA are built without MBEDTLS_THREADING_C, and bots on
different threads verifying their first connections at once were refused
as untrusted (two per smoke run). One process-wide recursive crypto lock
now guards every network-library entry point that touches them; the
smoke went from 2/2 failing to 3/3 clean. quic-transport adds a
concurrent-connect test. Refreshes the dev session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 08:38:13 -04:00

638 lines
26 KiB
C++

// M10.2b QUIC transport tests (ADR-0090): framing, bounded channels, exact CA pinning,
// and behaviour through the owned impairment relay (loss, duplication, reordering,
// jitter, MTU, corruption, outage), plus malformed peers and limits.
#include "evo/network/quic_transport.hpp"
#include "evo/network/dev_credentials.hpp"
#include "udp_relay.hpp"
#include <algorithm>
#include <array>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <functional>
#include <latch>
#include <set>
#include <source_location>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#endif
namespace {
using namespace evo::network;
using namespace evo::network::quic;
using Clock = std::chrono::steady_clock;
void check(bool ok, std::source_location at = std::source_location::current()) {
if (!ok)
throw std::runtime_error("quic transport line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
constexpr std::string_view name = "dev-region.evolution.test";
struct Files {
std::filesystem::path dir;
std::string ca_pem;
std::filesystem::path ca, certificate, key;
};
Files credentials(const std::string& tag) {
const auto made = generate_dev_credentials(DeploymentEnvironment::dev, name, 1,
std::chrono::system_clock::now());
CHECK(made.has_value());
Files f;
f.dir = std::filesystem::temp_directory_path() / ("evo-quic-transport-" + tag);
std::filesystem::remove_all(f.dir);
std::filesystem::create_directories(f.dir);
f.ca_pem = made->authority_pem;
f.ca = f.dir / "ca.pem";
f.certificate = f.dir / "server.pem";
f.key = f.dir / "server.key";
for (const auto& [path, text] : {std::pair{f.ca, made->authority_pem},
std::pair{f.certificate, made->server_certificate_pem},
std::pair{f.key, made->server_key_pem}}) {
std::ofstream out{path, std::ios::binary | std::ios::trunc};
out << text;
CHECK(out.good());
}
return f;
}
void set_env(const char* key, const std::string& value) {
#ifdef _WIN32
CHECK(_putenv_s(key, value.c_str()) == 0);
#else
CHECK(value.empty() ? ::unsetenv(key) == 0 : ::setenv(key, value.c_str(), 1) == 0);
#endif
}
struct Pair {
std::unique_ptr<Endpoint> server, client;
std::vector<Event> server_events, client_events;
ConnectionId server_id{}, client_id{};
void pump() {
for (auto& e : server->poll())
server_events.push_back(std::move(e));
for (auto& e : client->poll())
client_events.push_back(std::move(e));
}
bool until(const std::function<bool()>& done,
std::chrono::milliseconds limit = std::chrono::milliseconds{10000}) {
const auto end = Clock::now() + limit;
while (Clock::now() < end) {
pump();
if (done())
return true;
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
pump();
return done();
}
static const Event* find(const std::vector<Event>& events, EventKind kind) {
const auto it = std::find_if(events.begin(), events.end(),
[&](const Event& e) { return e.kind == kind; });
return it == events.end() ? nullptr : &*it;
}
bool connected() {
const bool ok = until([&] {
return find(server_events, EventKind::connected) &&
find(client_events, EventKind::connected);
});
if (ok) {
server_id = find(server_events, EventKind::connected)->connection;
client_id = find(client_events, EventKind::connected)->connection;
}
return ok;
}
std::vector<std::vector<std::uint8_t>> payloads(bool at_server, EventKind kind) const {
std::vector<std::vector<std::uint8_t>> out;
for (const auto& e : at_server ? server_events : client_events)
if (e.kind == kind)
out.push_back(e.bytes);
return out;
}
};
std::unique_ptr<Endpoint> serve(const Files& f, Limits limits = {}) {
ServerConfig c;
c.certificate_pem_file = f.certificate.string();
c.key_pem_file = f.key.string();
c.limits = limits;
auto made = Endpoint::serve(c);
CHECK(made.has_value());
return std::move(*made);
}
std::unique_ptr<Endpoint> dial(const Files& trusted, std::uint16_t port, Limits limits = {},
std::string server = std::string{name}) {
ClientConfig c;
c.port = port;
c.server_name = std::move(server);
c.authority_pem = trusted.ca_pem;
c.authority_pem_file = trusted.ca.string();
c.limits = limits;
auto made = Endpoint::connect(c);
CHECK(made.has_value());
return std::move(*made);
}
std::vector<std::uint8_t> numbered(std::uint32_t n, std::size_t size) {
std::vector<std::uint8_t> v(std::max<std::size_t>(size, 4), static_cast<std::uint8_t>(n * 7U));
v[0] = static_cast<std::uint8_t>(n);
v[1] = static_cast<std::uint8_t>(n >> 8U);
v[2] = static_cast<std::uint8_t>(n >> 16U);
v[3] = static_cast<std::uint8_t>(n >> 24U);
return v;
}
std::uint32_t number(const std::vector<std::uint8_t>& v) {
return static_cast<std::uint32_t>(v[0]) | (static_cast<std::uint32_t>(v[1]) << 8U) |
(static_cast<std::uint32_t>(v[2]) << 16U) | (static_cast<std::uint32_t>(v[3]) << 24U);
}
void framing() {
std::vector<std::vector<std::uint8_t>> out;
MessageReassembler r{1024};
std::vector<std::uint8_t> stream;
std::uint64_t state = 42;
const auto next = [&] {
state = state * 6364136223846793005ULL + 1442695040888963407ULL;
return static_cast<std::uint32_t>(state >> 33U);
};
std::vector<std::vector<std::uint8_t>> sent;
for (int i = 0; i < 2000; ++i) {
std::vector<std::uint8_t> m(next() % 1025, static_cast<std::uint8_t>(i));
const auto framed = frame_message(m);
stream.insert(stream.end(), framed.begin(), framed.end());
sent.push_back(std::move(m));
}
std::size_t at = 0;
while (at < stream.size()) { // Random chunking, including 1-byte pieces.
const std::size_t n = std::min<std::size_t>(stream.size() - at, 1 + next() % 3000);
CHECK(r.feed({stream.data() + at, n}, out));
at += n;
}
CHECK(out == sent && r.buffered() == 0);
MessageReassembler small{16};
std::vector<std::vector<std::uint8_t>> none;
const auto oversized = frame_message(std::vector<std::uint8_t>(17, 1));
CHECK(!small.feed(oversized, none) && none.empty()); // The stream is unusable afterwards.
MessageReassembler fresh{16};
CHECK(fresh.feed(frame_message({}), none) && none.size() == 1 &&
none[0].empty()); // Empty messages are valid.
}
void channels() {
const auto f = credentials("channels");
Pair p;
Limits server_limits;
server_limits.reliable_message = 1024;
p.server = serve(f, server_limits);
Limits client_limits;
client_limits.outbound_reliable_bytes = std::size_t{8} * 1024;
p.client = dial(f, p.server->port(), client_limits);
CHECK(p.connected());
// Reliable: 100 ordered messages each way.
for (std::uint32_t i = 0; i < 100; ++i) {
CHECK(p.client->send_message(p.client_id, numbered(i, 32)).has_value() || p.until([&] {
return p.client->send_message(p.client_id, numbered(i, 32)).has_value();
}));
CHECK(p.server->send_message(p.server_id, numbered(i, 32)).has_value());
}
CHECK(p.until([&] {
return p.payloads(true, EventKind::message).size() == 100 &&
p.payloads(false, EventKind::message).size() == 100;
}));
for (std::uint32_t i = 0; i < 100; ++i) {
CHECK(number(p.payloads(true, EventKind::message)[i]) == i);
CHECK(number(p.payloads(false, EventKind::message)[i]) == i);
}
// Realtime: datagrams both ways; size limits enforced locally.
CHECK(p.until([&] {
return p.client->datagram_limit(p.client_id) > 0 &&
p.server->datagram_limit(p.server_id) > 0;
}));
CHECK(p.client->datagram_limit(p.client_id) <= 1200);
CHECK(p.client->send_datagram(p.client_id, numbered(7, 100)).has_value());
CHECK(p.server->send_datagram(p.server_id, numbered(8, 100)).has_value());
CHECK(p.until([&] {
return !p.payloads(true, EventKind::datagram).empty() &&
!p.payloads(false, EventKind::datagram).empty();
}));
CHECK(p.client->send_datagram(p.client_id, std::vector<std::uint8_t>(1201, 1)).error() ==
SendError::too_large);
CHECK(
p.client
->send_message(p.client_id, std::vector<std::uint8_t>((std::size_t{64} * 1024) + 1, 1))
.error() == SendError::too_large);
CHECK(p.client->send_message(p.client_id + 99, numbered(1, 4)).error() ==
SendError::unknown_connection);
// Outbound reliable budget (8 KiB): a burst is refused rather than buffered without bound.
bool busy = false;
for (int i = 0; i < 64 && !busy; ++i)
busy = p.client->send_message(p.client_id, std::vector<std::uint8_t>(1000, 2))
.error_or(SendError::transport) == SendError::busy;
CHECK(busy && p.client->counters().messages_refused_outbound > 0);
// The server's 1 KiB message limit: a larger peer message is a protocol violation.
CHECK(p.until([&] {
return p.client->send_message(p.client_id, std::vector<std::uint8_t>(2000, 3)).has_value();
}));
CHECK(p.until([&] {
const auto* closed = Pair::find(p.server_events, EventKind::closed);
return closed != nullptr && closed->cause == CloseCause::protocol;
}));
CHECK(p.until([&] { return Pair::find(p.client_events, EventKind::closed) != nullptr; }));
std::filesystem::remove_all(f.dir);
}
void pinning() {
const auto good = credentials("pin-good");
const auto attacker = credentials("pin-attacker"); // Same name, another CA.
// OpenSSL would also trust SSL_CERT_FILE; the owned pin must not.
set_env("SSL_CERT_FILE", attacker.ca.string());
{
Pair p;
p.server = serve(attacker);
p.client = dial(good, p.server->port());
CHECK(p.until([&] {
const auto* closed = Pair::find(p.client_events, EventKind::closed);
return closed != nullptr && closed->cause == CloseCause::untrusted;
}));
CHECK(Pair::find(p.client_events, EventKind::connected) == nullptr);
CHECK(Pair::find(p.server_events, EventKind::connected) == nullptr);
}
{
// The genuine server still connects with the same environment.
Pair p;
p.server = serve(good);
p.client = dial(good, p.server->port());
const bool ok = p.connected();
if (!ok)
if (const auto* c = Pair::find(p.client_events, EventKind::closed))
std::fprintf(stderr,
"genuine server with SSL_CERT_FILE set: client closed, cause %d\n",
static_cast<int>(c->cause));
CHECK(ok);
}
set_env("SSL_CERT_FILE", "");
{
Pair p;
p.server = serve(good);
p.client = dial(good, p.server->port(), {}, "wrong.evolution.test");
CHECK(p.until([&] {
const auto* closed = Pair::find(p.client_events, EventKind::closed);
return closed != nullptr && closed->cause == CloseCause::untrusted;
}));
}
std::filesystem::remove_all(good.dir);
std::filesystem::remove_all(attacker.dir);
}
void impaired() {
const auto f = credentials("impaired");
impair::Impairment rough;
rough.loss = 0.10;
rough.duplicate = 0.10;
rough.reorder = 0.20;
rough.corrupt = 0.05;
rough.delay = std::chrono::milliseconds{5};
rough.jitter = std::chrono::milliseconds{10};
Pair p;
p.server = serve(f);
const auto relay = impair::UdpRelay::start(p.server->port(), rough, rough, 0xE70);
CHECK(relay != nullptr);
p.client = dial(f, relay->port());
CHECK(p.connected());
constexpr std::uint32_t messages = 200, datagrams = 300;
std::uint32_t sent = 0;
for (std::uint32_t i = 0; i < datagrams; ++i) {
if (!p.client->send_datagram(
p.client_id,
numbered(i, 200))) { /* Busy or too large: dropped like network loss. */
} // Busy/too large: dropped like loss.
if (sent < messages && p.client->send_message(p.client_id, numbered(sent, 300)).has_value())
++sent;
p.pump();
std::this_thread::sleep_for(std::chrono::milliseconds{2});
}
CHECK(p.until(
[&] {
while (sent < messages &&
p.client->send_message(p.client_id, numbered(sent, 300)).has_value())
++sent;
return p.payloads(true, EventKind::message).size() == messages;
},
std::chrono::milliseconds{30000}));
const auto got = p.payloads(true, EventKind::message);
for (std::uint32_t i = 0; i < messages; ++i)
CHECK(number(got[i]) == i); // Exactly once, in order, despite loss/duplication/reordering.
std::set<std::uint32_t> seen;
for (const auto& d : p.payloads(true, EventKind::datagram))
CHECK(seen.insert(number(d)).second); // Never duplicated to the application.
CHECK(!seen.empty() && seen.size() < datagrams); // Some lost, none invented.
const auto counters = relay->counters();
CHECK(counters.dropped > 0 && counters.duplicated > 0 && counters.reordered > 0 &&
counters.corrupted > 0);
std::printf("quic impaired: %zu/%u datagrams, %u/%u messages; relay forwarded=%llu "
"dropped=%llu dup=%llu "
"reordered=%llu corrupted=%llu\n",
seen.size(), datagrams, messages, messages,
static_cast<unsigned long long>(counters.forwarded),
static_cast<unsigned long long>(counters.dropped),
static_cast<unsigned long long>(counters.duplicated),
static_cast<unsigned long long>(counters.reordered),
static_cast<unsigned long long>(counters.corrupted));
std::filesystem::remove_all(f.dir);
}
void mtu() {
const auto f = credentials("mtu");
impair::Impairment narrow;
narrow.max_payload = 1252; // An IPv6 minimum path (1280) less IP/UDP headers.
Pair p;
p.server = serve(f);
const auto relay = impair::UdpRelay::start(p.server->port(), narrow, narrow, 7);
CHECK(relay != nullptr);
p.client = dial(f, relay->port());
CHECK(p.connected());
CHECK(p.until([&] { return p.client->datagram_limit(p.client_id) > 0; }));
// A full 1,200-byte budget datagram crosses a minimum path both ways and keeps
// crossing it (path discovery may probe larger packets; the path drops only those).
CHECK(p.connected());
const auto limit = p.client->datagram_limit(p.client_id);
CHECK(limit == 1200);
CHECK(p.client->send_datagram(p.client_id, std::vector<std::uint8_t>(limit + 1, 1)).error() ==
SendError::too_large);
for (int i = 0; i < 20; ++i) {
if (!p.client->send_datagram(
p.client_id,
std::vector<std::uint8_t>(
1200, static_cast<std::uint8_t>(
i)))) { /* Busy or too large: dropped like network loss. */
}
if (!p.server->send_datagram(
p.server_id,
std::vector<std::uint8_t>(
1200, static_cast<std::uint8_t>(
i)))) { /* Busy or too large: dropped like network loss. */
}
CHECK(p.client->send_message(p.client_id, numbered(static_cast<std::uint32_t>(i), 1100))
.has_value());
p.pump();
std::this_thread::sleep_for(std::chrono::milliseconds{50});
}
CHECK(p.until([&] {
return p.payloads(true, EventKind::message).size() == 20 &&
!p.payloads(true, EventKind::datagram).empty() &&
!p.payloads(false, EventKind::datagram).empty();
}));
CHECK(p.payloads(true, EventKind::datagram)[0].size() == 1200);
CHECK(Pair::find(p.client_events, EventKind::closed) == nullptr);
std::printf("quic mtu: 1200-byte datagrams over a 1252-byte UDP path (%llu larger probe "
"packets dropped)\n",
static_cast<unsigned long long>(relay->counters().oversized));
std::filesystem::remove_all(f.dir);
}
void outage() {
const auto f = credentials("outage");
Limits fast;
fast.idle_timeout = std::chrono::milliseconds{1000};
fast.keep_alive = std::chrono::milliseconds{300};
Pair p;
p.server = serve(f, fast);
const auto relay = impair::UdpRelay::start(p.server->port(), {}, {}, 9);
CHECK(relay != nullptr);
p.client = dial(f, relay->port(), fast);
CHECK(p.connected());
impair::Impairment dead;
dead.loss = 1.0;
relay->set(dead, dead);
const auto start = Clock::now();
CHECK(p.until(
[&] {
const auto* s = Pair::find(p.server_events, EventKind::closed);
const auto* c = Pair::find(p.client_events, EventKind::closed);
return s != nullptr && c != nullptr && s->cause == CloseCause::idle &&
c->cause == CloseCause::idle;
},
std::chrono::milliseconds{8000}));
std::printf(
"quic outage: both sides idle-closed after %lld ms\n",
static_cast<long long>(
std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - start).count()));
std::filesystem::remove_all(f.dir);
}
void bounds() {
const auto f = credentials("bounds");
Limits tight;
tight.inbound_datagrams = 4;
tight.inbound_reliable_bytes = 4096;
tight.max_connections = 1;
Pair p;
p.server = serve(f, tight);
p.client = dial(f, p.server->port());
CHECK(p.until([&] { return Pair::find(p.client_events, EventKind::connected) != nullptr; }));
p.client_id = Pair::find(p.client_events, EventKind::connected)->connection;
CHECK(p.until([&] {
for (auto& e : p.client->poll())
p.client_events.push_back(std::move(e));
return p.client->datagram_limit(p.client_id) > 0;
}));
// Datagrams pile up while the server does not poll: only the newest four survive.
for (std::uint32_t i = 0; i < 50; ++i) {
if (!p.client->send_datagram(
p.client_id, numbered(i, 64))) { /* Busy or too large: dropped like network loss. */
}
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
std::this_thread::sleep_for(std::chrono::milliseconds{200});
auto server_events = p.server->poll();
std::vector<std::uint32_t> kept;
for (const auto& e : server_events)
if (e.kind == EventKind::datagram)
kept.push_back(number(e.bytes));
p.server_events.insert(p.server_events.end(), server_events.begin(), server_events.end());
CHECK(!kept.empty() && kept.size() <= 4 && std::is_sorted(kept.begin(), kept.end()));
CHECK(p.server->counters().datagrams_dropped_inbound > 0);
const auto* accepted = Pair::find(p.server_events, EventKind::connected);
CHECK(accepted != nullptr);
p.server_id = accepted->connection;
// A second client exceeds max_connections and is refused.
auto extra = dial(f, p.server->port());
bool refused = false;
for (int i = 0; i < 5000 && !refused; ++i) {
for (const auto& e : extra->poll())
refused = refused || e.kind == EventKind::closed;
(void)p.server->poll(); // Keep the first connection serviced.
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
CHECK(refused && p.server->counters().connections_refused > 0);
// Reliable bytes beyond 4 KiB awaiting poll close the connection as overloaded.
for (int i = 0; i < 40; ++i)
if (!p.client->send_message(
p.client_id, std::vector<std::uint8_t>(
1000, 4))) { /* Busy or too large: dropped like network loss. */
}
const auto end = Clock::now() + std::chrono::seconds{10};
const Event* closed = nullptr;
std::vector<Event> late;
while (Clock::now() < end && closed == nullptr) {
std::this_thread::sleep_for(std::chrono::milliseconds{50}); // Server lags behind.
for (auto& e : p.server->poll())
late.push_back(std::move(e));
closed = Pair::find(late, EventKind::closed);
(void)p.client->poll();
}
CHECK(closed != nullptr && closed->cause == CloseCause::overloaded);
std::filesystem::remove_all(f.dir);
}
void garbage_and_close() {
const auto f = credentials("garbage");
Pair p;
p.server = serve(f);
// Random UDP datagrams at the listener: ignored, nothing surfaces.
#ifdef _WIN32
using Native = SOCKET;
#else
using Native = int;
#endif
const Native s = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#ifdef _WIN32
if (s == INVALID_SOCKET)
throw std::runtime_error("quic transport: no UDP socket");
#else
if (s < 0)
throw std::runtime_error("quic transport: no UDP socket");
#endif
sockaddr_in to{};
to.sin_family = AF_INET;
to.sin_port = htons(p.server->port());
to.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
std::uint64_t state = 1;
for (std::size_t i = 0; i < 500; ++i) {
std::vector<char> junk(1 + (i * 37) % 1400);
for (auto& b : junk) {
state = state * 6364136223846793005ULL + 1;
b = static_cast<char>(state >> 56U);
}
#ifdef _WIN32
const auto length = static_cast<int>(junk.size());
#else
const auto length = junk.size();
#endif
(void)::sendto(s, junk.data(), length, 0, reinterpret_cast<const sockaddr*>(&to),
sizeof to);
}
#ifdef _WIN32
closesocket(s);
#else
::close(s);
#endif
std::this_thread::sleep_for(std::chrono::milliseconds{200});
CHECK(p.server->poll().empty());
// The listener still serves a genuine client; then a clean local close.
p.client = dial(f, p.server->port());
CHECK(p.connected());
p.client->close(p.client_id);
CHECK(p.until([&] {
const auto* c = Pair::find(p.client_events, EventKind::closed);
const auto* s2 = Pair::find(p.server_events, EventKind::closed);
return c != nullptr && s2 != nullptr && c->cause == CloseCause::local &&
s2->cause == CloseCause::peer;
}));
CHECK(p.client->send_message(p.client_id, numbered(1, 4)).error() ==
SendError::unknown_connection);
std::filesystem::remove_all(f.dir);
}
} // namespace
// M10.9d (ADR-0097): client endpoints on several threads connecting at the same moment all
// connect and pass the owned pin check. Mbed TLS runs without its threading layer; evo-load
// saw two concurrent first verifications refused as `untrusted` before the shared crypto
// lock. This test covers concurrent connects; it does not reliably reproduce that race (PSA
// is already initialised here by the credential generation), which evo-load's smoke does.
void concurrent_clients() {
const auto f = credentials("concurrent");
Limits limits;
limits.max_connections = 64; // 5 rounds x 8, whatever the server has not yet reaped.
auto server = serve(f, limits);
constexpr int threads = 8;
for (int round = 0; round < 5; ++round) {
std::atomic<int> connected{0}, finished{0};
std::array<std::atomic<int>, 8> causes{};
std::latch start{threads};
std::vector<std::thread> clients;
clients.reserve(threads);
for (int t = 0; t < threads; ++t)
clients.emplace_back([&] {
start.arrive_and_wait();
auto client = dial(f, server->port());
const auto end = std::chrono::steady_clock::now() + std::chrono::seconds{10};
bool done = false;
while (!done && std::chrono::steady_clock::now() < end) {
for (const auto& e : client->poll()) {
if (e.kind == EventKind::connected) {
++connected;
done = true;
} else if (e.kind == EventKind::closed) {
causes[static_cast<std::size_t>(e.cause)] += 1;
done = true;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
++finished;
});
while (finished < threads) {
(void)server->poll();
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
for (auto& c : clients)
c.join();
if (connected != threads) {
std::printf("concurrent round %d connected=%d", round, connected.load());
for (std::size_t i = 0; i < causes.size(); ++i)
std::printf(" cause%zu=%d", i, causes.at(i).load());
std::printf("\n");
}
CHECK(connected == threads);
for (int i = 0; i < 200; ++i) { // Let the server see the closes.
(void)server->poll();
std::this_thread::sleep_for(std::chrono::milliseconds{1});
}
}
std::filesystem::remove_all(f.dir);
}
int main() try {
framing();
concurrent_clients();
channels();
pinning();
impaired();
mtu();
outage();
bounds();
garbage_and_close();
std::puts("quic transport tests passed");
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
}