std::string name;

std::string filename;

std::string content_type;

std::string transfer_encoding;

std::string data;

bool operator==(const part_record&) const = default;

std::string out;

for (const unsigned char c : raw) {

if (c >= 0x20 && c < 0x7f) {

out.push_back(static_cast<char>(c));

} else {

char buf[8];

std::snprintf(buf, sizeof(buf), "\\x%02x", c);

out += buf;

}

}

return out;

std::string out = "[";

bool first = true;

for (const part_record& p : parts) {

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

first = false;

out += "(" + quote(p.name) + "|" + quote(p.filename) + "|"

+ quote(p.content_type) + "|" + quote(p.transfer_encoding)

+ "|" + quote(p.data) + ")";

}

return out + "]";

public:

std::vector<part_record> parts;

int data_callbacks = 0;

http::outcome on_part_begin(const multipart_part_meta& m) override {

parts.push_back(part_record{std::string(m.name),

std::string(m.filename),

std::string(m.content_type),

std::string(m.transfer_encoding),

std::string()});

return http::outcome::okay();

}

http::outcome on_part_data(std::span<const std::byte> data) override {

++data_callbacks;

const char* raw = reinterpret_cast<const char*>(data.data());

if (!parts.empty()) parts.back().data.append(raw, data.size());

return http::outcome::okay();

}

http::outcome on_part_end() override {

return http::outcome::okay();

}

std::uint64_t bytes = default_bytes;

std::uint64_t parts = default_parts;

std::uint64_t part_bytes = default_part_bytes;

std::uint64_t header_bytes = default_header_bytes;

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;

const std::vector<part_record>& expected) {

if (got == expected) return "";

return "got " + render(got) + " want " + render(expected);

const std::vector<part_record>& expected) {

if (got.size() > expected.size()) return "more parts than expected";

for (std::size_t i = 0; i < got.size(); ++i) {

const part_record& g = got[i];

const part_record& w = expected[i];

const bool meta_eq = g.name == w.name && g.filename == w.filename

&& g.content_type == w.content_type

&& g.transfer_encoding == w.transfer_encoding;

if (!meta_eq) return "part " + std::to_string(i) + " metadata";

if (w.data.compare(0, g.data.size(), g.data) != 0) {

return "part " + std::to_string(i) + " data is not a prefix";

}

}

return "";

if (got == want) return "";

return "parts_completed " + std::to_string(got) + " want "

+ std::to_string(want);

const caps& limits,

const std::vector<part_record>& expected) {

recording_events events;

multipart_decoder d(boundary, limits.bytes, limits.parts,

limits.part_bytes, limits.header_bytes, events);

const http::outcome fed = d.feed(bytes_of(body));

if (!fed.ok()) return "feed failed: " + fed.message();

const http::outcome done = d.finish();

if (!done.ok()) return "finish failed: " + done.message();

const std::string diff = parts_diff(events.parts, expected);

if (!diff.empty()) return diff;

return completed_diff(d.parts_completed(),

static_cast<std::uint64_t>(expected.size()));

const std::string& boundary,

std::size_t chunk, const caps& limits,

const std::vector<part_record>& expected) {

recording_events events;

multipart_decoder d(boundary, limits.bytes, limits.parts,

limits.part_bytes, limits.header_bytes, events);

for (std::size_t at = 0; at < body.size(); at += chunk) {

std::size_t n = chunk;

if (at + n > body.size()) n = body.size() - at;

const http::outcome fed =

d.feed(bytes_of(body.substr(at, n)));

if (!fed.ok()) {

return "chunked feed at " + std::to_string(at) + " failed: "

+ fed.message();

}

}

const http::outcome done = d.finish();

if (!done.ok()) return "chunked finish failed: " + done.message();

const std::string diff = parts_diff(events.parts, expected);

if (!diff.empty()) return "chunked: " + diff;

return completed_diff(d.parts_completed(),

static_cast<std::uint64_t>(expected.size()));

const std::string& boundary,

const std::vector<part_record>& expected) {

for (std::size_t k = 0; k <= body.size(); ++k) {

recording_events events;

multipart_decoder d(boundary, default_bytes, default_parts,

default_part_bytes, default_header_bytes,

events);

const http::outcome first =

d.feed(bytes_of(body.substr(0, k)));

if (!first.ok()) {

return "first feed (k=" + std::to_string(k)

+ ") failed: " + first.message();

}

const http::outcome rest = d.feed(bytes_of(body.substr(k)));

if (!rest.ok()) {

return "second feed (k=" + std::to_string(k)

+ ") failed: " + rest.message();

}

const http::outcome done = d.finish();

if (!done.ok()) {

return "finish (k=" + std::to_string(k)

+ ") failed: " + done.message();

}

const std::string diff = parts_diff(events.parts, expected);

if (!diff.empty()) {

return "split k=" + std::to_string(k) + ": " + diff;

}

}

return "";

http::outcome_code code, const caps& limits,

const std::vector<part_record>& stored) {

recording_events events;

multipart_decoder d(boundary, limits.bytes, limits.parts,

limits.part_bytes, limits.header_bytes, events);

const http::outcome fed = d.feed(bytes_of(body));

const http::outcome observed = fed.ok() ? d.finish() : fed;

if (observed.ok()) return "decode unexpectedly succeeded";

if (observed.code() != code) {

return "failure code " + std::to_string(

static_cast<int>(observed.code()))

+ " want " + std::to_string(static_cast<int>(code));

}

return parts_diff(events.parts, stored);

const std::string& boundary,

http::outcome_code code, const caps& limits,

const std::vector<part_record>& expected) {

recording_events events;

multipart_decoder d(boundary, limits.bytes, limits.parts,

limits.part_bytes, limits.header_bytes, events);

const http::outcome fed = d.feed(bytes_of(body));

const http::outcome observed = fed.ok() ? d.finish() : fed;

if (observed.ok()) return "decode unexpectedly succeeded";

if (observed.code() != code) {

return "failure code " + std::to_string(

static_cast<int>(observed.code()));

}

return prefix_diff(events.parts, expected);

const std::string& boundary,

http::outcome_code code, const caps& limits,

const std::vector<part_record>& stored) {

recording_events events;

multipart_decoder d(boundary, limits.bytes, limits.parts,

limits.part_bytes, limits.header_bytes, events);

const http::outcome fed = d.feed(bytes_of(body));

if (fed.ok()) return "feed unexpectedly succeeded";

if (fed.code() != code) return "first failure code mismatch";

const std::size_t parts_at_failure = events.parts.size();

const http::outcome again = d.feed(bytes_of("--x\r\n"));

if (again.code() != code) return "second feed not sticky";

const http::outcome done = d.finish();

if (done.code() != code) return "finish not sticky";

if (events.parts.size() != parts_at_failure) {

return "a sticky failure emitted more parts";

}

return parts_diff(events.parts, stored);

return "--PARITY096B\r\n"

"Content-Disposition: form-data; name=\"note\"\r\n"

"\r\n"

"hello\r\n"

"--PARITY096B--\r\n";

return "--B\r\n"

"Content-Disposition: form-data; name=\"field1\"\r\n"

"\r\n"

"value1\r\n"

"--B\r\n"

"Content-Disposition: form-data; name=\"file1\"; filename=\"a.txt\"\r\n"

"Content-Type: text/plain\r\n"

"\r\n"

"file bytes\r\n"

"--B--\r\n";

return {part_record{"field1", "", "", "", "value1"},

part_record{"file1", "a.txt", "text/plain", "",

"file bytes"}};