srv::budget_limits limits;

limits.set(srv::resource::routes, capacity);

return srv::resource_budget::root(limits);

std::vector<std::byte> out;

out.reserve(s.size());

for (const char c : s) {

out.push_back(std::byte(static_cast<unsigned char>(c)));

}

return out;

http::request_head head;

head.raw_target = "/echo?query=1";

head.route_path = "/echo";

head.request_method = http::method::known(http::method_id::post);

head.request_protocol = http::protocol::http_1_1;

if (content_type != nullptr) {

head.head_fields.append("Content-Type", content_type);

}

return head;

public:

void on_admit(const httpserver::body_policy& policy) override {

++admit_calls;

admitted_bytes = policy.max_buffer_bytes;

}

void on_respond(const http::status& s, const http::fields& f) override {

++respond_calls;

code = s.code();

responded = f;

}

httpserver::websocket_upgrade_result on_upgrade(const httpserver::ws_upgrade_options&) override {

++upgrade_calls;

httpserver::websocket_upgrade_result result; result.session.emplace(); return result; }

void on_abort() override {

++abort_calls;

}

int admit_calls = 0;

int respond_calls = 0;

int upgrade_calls = 0;

int abort_calls = 0;

std::uint16_t code = 0;

http::fields responded;

std::uint64_t admitted_bytes = 0;

std::string out;

bool first = true;

for (const std::pair<std::string, std::string>& e : fields.entries()) {

if (!first) out += ";";

first = false;

out += e.first + "=" + e.second;

}

return out;

form_observed& seen,

const forms::urlencoded_limits& limits) {

return registry.route(

http::method::known(http::method_id::post), "/echo",

forms::make_urlencoded_route(

limits,

[&seen](const http::request_head&,

const forms::form_fields& fields) -> srv::sync_response {

++seen.invoked;

seen.rendered = render_fields(fields);

srv::sync_response out;

out.status = http::status::from_code(200);

out.fields.append("Content-Type", "text/plain");

out.body = bytes(seen.rendered);

return out;

}));

for (int i = 0; i < spins && flag == 0; ++i) {

std::this_thread::sleep_for(std::chrono::milliseconds(1));

ex.run_pending();

}

return flag != 0;

const forms::urlencoded_limits& limits) {

capturing_sink sink;

fake::scripted_body_source source;

fake::scripted_body_sink responses;

for (const std::string& segment : segments) {

source.stage(bytes(segment));

}

source.stage_end();

exchange x(make_head(k_type), &sink, 0, &source, &responses);

manual_executor ex;

int deliveries = 0;

forms::form_read read;

spawn(ex, forms::read_urlencoded(x, limits),

[&](task_result<forms::form_read> r) {

++deliveries;

if (r.has_value()) read = r.value();

});

drain(ex);

if (deliveries != 1) return "deliveries " + std::to_string(deliveries);

if (sink.admit_calls != 1) return "admit calls missing";

if (sink.admitted_bytes != limits.max_total_bytes) {

return "admission did not carry the byte cap";

}

if (sink.respond_calls != 0) return "the read committed a response";

return read.ok() ? "ok:" + render_fields(read.fields)

: "code:" + std::to_string(

static_cast<int>(read.status.code()));

const std::string verdict = stream_read_diff(

{"a=", "1&b=tw", "%6F"}, forms::urlencoded_limits{});

if (verdict != "ok:a=1;b=two") return "verdict was " + verdict;

return "";

const std::string verdict = stream_read_diff(

{"a=1&b=%G1"}, forms::urlencoded_limits{});

if (verdict != "code:1") {

return "verdict was " + verdict + " (1 = invalid_argument)";

}

return "";

const std::string verdict = stream_read_diff(

{"a=1&b="}, forms::urlencoded_limits{5, 64});

if (verdict != "code:3") {

return "verdict was " + verdict + " (3 = limit_exceeded)";

}

return "";