Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / fetch / infrastructure / http / tests_fetch_http_1.lucb

#==============================================================================================
#
#   tests_fetch_http_1 - LibHTTP and Fetch/Infrastructure/HTTP: the donor's unit tests and the
#   oracle's cases
#
#   DESCRIPTION:
#       Port of Tests/LibHTTP/TestHTTPUtils.cpp's tests of the ported files (collect an HTTP
#       quoted string, token validation, extracting header values; lines 16-65, 129-247; the
#       Cache-Control tests are of LibHTTP/Cache, which is not ported), and the runner of
#       tests_fetch_http_cases: each case's operation is run and its result printed the way the
#       local oracle prints the reference build's (oracles/luce-browser-engine/fetch_http).
#
#==============================================================================================

# mark: TestHTTPUtils.cpp =======================================================================

## `HTTP::collect_an_http_quoted_string(lexer)` of `text` after ignoring `skip` bytes, compared with `expected`.
func fetch_http_test_quoted_string(text: str, skip: usize, expected: str):
    var lexer = ak.generic_lexer_new(ak.sv(text))
    ak.generic_lexer_ignore(&lexer, skip)
    let result = http_collect_an_http_quoted_string(&lexer)
    assert(ak.string_eq_string_view(&result, ak.sv(expected)))

## Ported from TestHTTPUtils.cpp:16 collect_an_http_quoted_string.
test "HTTP: collect an HTTP quoted string":
    fetch_http_test_quoted_string("\"\"", 0, "\"\"")
    fetch_http_test_quoted_string("\"abc\"", 0, "\"abc\"")
    fetch_http_test_quoted_string("foo \"abc\"", 4, "\"abc\"")
    fetch_http_test_quoted_string("foo=\"abc\"", 4, "\"abc\"")
    fetch_http_test_quoted_string("foo=\"abc\" bar", 4, "\"abc\"")
    fetch_http_test_quoted_string("\"abc\" bar", 0, "\"abc\"")

## Ported from TestHTTPUtils.cpp:129 token_validation.
test "HTTP: token validation":
    assert(http_is_method(ak.sv("GET")))
    assert(http_is_method(ak.sv("PATCH")))
    assert(http_is_method(ak.sv("M-SEARCH")))
    assert(not http_is_method(ak.sv("")))
    assert(not http_is_method(ak.sv("GET ")))
    assert(not http_is_method(ak.sv("GE:T")))

    assert(http_is_header_name(ak.sv("Content-Type")))
    assert(http_is_header_name(ak.sv("X-Custom_Header")))
    assert(not http_is_header_name(ak.sv("")))
    assert(not http_is_header_name(ak.sv("Content Type")))
    assert(not http_is_header_name(ak.sv("Content:Type")))

## `HTTP::Header { name, value }.extract_header_values()`.
func fetch_http_test_extract(name: str, value: const u8[]) -> ak.Vector[ak.ByteString]?:
    let header = http_header_create(ak.sv(name), ak.string_view_from_bytes(value))
    return http_header_extract_header_values(&header)

## `EXPECT_EQ(result, (Vector<ByteString> { expected... }))`.
func fetch_http_test_values_are(result: ak.Vector[ak.ByteString]?, expected: const str[]) -> bool:
    var values = result else return false
    if ak.vector_size(&values) != expected.length:
        return false
    for (index, value) in ak.vector_span(&values).indexed():
        if not ak.byte_string_eq_string_view(&value, ak.sv(expected[index])):
            return false
    return true

## A header of TestHTTPUtils.cpp's extract_header_values table: true = 1#token, false = #token.
struct FetchHttpTestHeader:
    var name: str
    var requires_at_least_one: bool

## Ported from TestHTTPUtils.cpp:144 extract_header_values.
test "HTTP: extract header values":
    let headers: FetchHttpTestHeader[6] = [
        FetchHttpTestHeader(name = "Access-Control-Expose-Headers", requires_at_least_one = false),
        FetchHttpTestHeader(name = "access-control-expose-headers", requires_at_least_one = false),
        FetchHttpTestHeader(name = "Access-Control-Allow-Headers", requires_at_least_one = false),
        FetchHttpTestHeader(name = "Access-Control-Allow-Methods", requires_at_least_one = false),
        FetchHttpTestHeader(name = "Access-Control-Request-Headers", requires_at_least_one = true),
        FetchHttpTestHeader(name = "Accept-Ranges", requires_at_least_one = true),
    ]

    for test_header in headers:
        let header = test_header.name

        # Valid single token.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"bb-8"), ["bb-8"]))

        # Valid multiple tokens, whitespace trimmed.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"bb-8, no"), ["bb-8", "no"]))

        # Wildcard is a valid token.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"*"), ["*"]))

        # Single-quoted tokens are valid (apostrophe is a tchar).
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"'bb-8',bb-8"), ["'bb-8'", "bb-8"]))

        # Leading/trailing commas: empty parts discarded.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b",bb-8,"), ["bb-8"]))

        # Empty value and only-commas.
        let empty_values: str[3] = ["", ",   ,", ","]
        for value in empty_values:
            let result = fetch_http_test_extract(header, value.bytes)
            if test_header.requires_at_least_one:
                assert(result == none)
            else:
                let values = result else trap("expected an empty list")
                assert(ak.vector_is_empty(&values))

        # Empty list element ignored.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"foo , ,bar,charlie"), ["foo", "bar", "charlie"]))

        # Leading empty list component.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b",foo,bar"), ["foo", "bar"]))

        # Space inside a token is invalid.
        assert(fetch_http_test_extract(header, b"no no") == none)

        # Double-quote is invalid.
        assert(fetch_http_test_extract(header, b"\"bb-8\",bb-8") == none)

        # @ is invalid.
        assert(fetch_http_test_extract(header, b"@invalid,bb-8") == none)

        # Vertical tab (0x0B) is invalid.
        assert(fetch_http_test_extract(header, b"bb-8\x0B") == none)

        # Form feed (0x0C) is invalid.
        assert(fetch_http_test_extract(header, b"bb-8\x0C") == none)

        # Invalid token alongside a valid one still fails.
        assert(fetch_http_test_extract(header, b"bb-8,no no") == none)

        # Whitespace-only item is ignored.
        assert(fetch_http_test_values_are(fetch_http_test_extract(header, b"bb-8,  ,no"), ["bb-8", "no"]))

    # Other headers: returned as a single-element list regardless of content.
    assert(fetch_http_test_values_are(fetch_http_test_extract("Content-Type", b"text/html; charset=utf-8"), ["text/html; charset=utf-8"]))

# mark: The oracle's cases ======================================================================

## A case of the p2b oracle: an operation, its arguments (separated by 0x1F) and the oracle's result line.
struct FetchHttpCase:
    var op: str
    var argument_count: usize
    var arguments: const u8[]
    var expected: const u8[]

## The arguments of a case.
func fetch_http_test_arguments(test_case: const FetchHttpCase*) -> ak.Vector[ak.StringView]:
    var arguments = ak.Vector[ak.StringView]()
    if test_case.argument_count == 0:
        return arguments
    var start: usize = 0
    for (index, byte) in test_case.arguments.indexed():
        if byte == 0x1f:
            ak.vector_append_t(&arguments, ak.string_view_from_bytes(test_case.arguments[start..<index]))
            start = index + 1
    ak.vector_append_t(&arguments, ak.string_view_from_bytes(test_case.arguments[start..]))
    assert(ak.vector_size(&arguments) == test_case.argument_count)
    return arguments

## The oracle's `escape`: `\\`, `\n`, `\t`, and `\xHH` for every other control or non-ASCII byte.
func fetch_http_test_escape(builder: ak.StringBuilder*, view: ak.StringView):
    let digits = "0123456789ABCDEF"
    for byte in ak.string_view_bytes(&view):
        if byte == '\\':
            ak.string_builder_append(builder, "\\\\")
        elif byte == '\n':
            ak.string_builder_append(builder, "\\n")
        elif byte == '\t':
            ak.string_builder_append(builder, "\\t")
        elif byte < 0x20 or byte >= 0x7f:
            ak.string_builder_append(builder, "\\x")
            ak.string_builder_append_code_point(builder, digits.bytes[(usize)(byte >> 4)])
            ak.string_builder_append_code_point(builder, digits.bytes[(usize)(byte & 0x0f)])
        else:
            ak.string_builder_append_code_point(builder, byte)

## The oracle's `b`.
func fetch_http_test_bool(builder: ak.StringBuilder*, value: bool):
    ak.string_builder_append(builder, "true" if value else "false")

## The oracle's `list` of Strings.
func fetch_http_test_strings(builder: ak.StringBuilder*, values: const ak.Vector[ak.String]*):
    ak.string_builder_append(builder, "[")
    for (index, value) in ak.vector_span_const(values).indexed():
        if index > 0:
            ak.string_builder_append(builder, ", ")
        ak.string_builder_append(builder, "\"")
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&value))
        ak.string_builder_append(builder, "\"")
    ak.string_builder_append(builder, "]")

## The oracle's `list_bs` of ByteStrings.
func fetch_http_test_byte_strings(builder: ak.StringBuilder*, values: const ak.Vector[ak.ByteString]*):
    ak.string_builder_append(builder, "[")
    for (index, value) in ak.vector_span_const(values).indexed():
        if index > 0:
            ak.string_builder_append(builder, ", ")
        ak.string_builder_append(builder, "\"")
        fetch_http_test_escape(builder, ak.byte_string_view(&value))
        ak.string_builder_append(builder, "\"")
    ak.string_builder_append(builder, "]")

## The oracle's `headers`.
func fetch_http_test_headers(builder: ak.StringBuilder*, headers: const ak.Vector[HttpHeader]*):
    ak.string_builder_append(builder, "[")
    for (index, header) in ak.vector_span_const(headers).indexed():
        if index > 0:
            ak.string_builder_append(builder, ", ")
        ak.string_builder_append(builder, "(")
        fetch_http_test_escape(builder, ak.byte_string_view(&header.name))
        ak.string_builder_append(builder, ": ")
        fetch_http_test_escape(builder, ak.byte_string_view(&header.value))
        ak.string_builder_append(builder, ")")
    ak.string_builder_append(builder, "]")

## The oracle's `opt_u64`.
func fetch_http_test_optional_u64(builder: ak.StringBuilder*, value: u64?):
    if let number = value:
        ak.format_u64(builder, number)
    else:
        ak.string_builder_append(builder, "null")

## The oracle's `mime`.
func fetch_http_test_mime(builder: ak.StringBuilder*, mime_type: MimeType?):
    if let actual = mime_type:
        let serialized = mime_type_serialized(&actual)
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
    else:
        ak.string_builder_append(builder, "failure")

## A header made from two case arguments.
func fetch_http_test_header(name: ak.StringView, value: ak.StringView) -> HttpHeader:
    return http_header_create(name, value)

## The `vary` callback of the oracle's header_list: append each `Vary` header to the list in `context`.
func fetch_http_test_collect_vary(context: void*?, value: ak.StringView) -> ak.IterationDecision:
    let values = (ak.Vector[ak.ByteString]*)(context else trap("vary: no list"))
    ak.vector_append_t(values, ak.byte_string_from_string_view(value))
    return ak.IterationDecision.continue_

## The oracle's `header_list`: a header list built and queried by `arguments`.
func fetch_http_test_header_list(builder: ak.StringBuilder*, arguments: const ak.StringView[]):
    let list = http_header_list_create()
    var outputs = 0
    var i: usize = 0
    while i < arguments.length:
        let op = arguments[i]
        i += 1
        if ak.string_view_equals(&op, "A"):
            http_header_list_append(list, fetch_http_test_header(arguments[i], arguments[i + 1]))
            i += 2
            continue
        if ak.string_view_equals(&op, "S"):
            http_header_list_set(list, fetch_http_test_header(arguments[i], arguments[i + 1]))
            i += 2
            continue
        if ak.string_view_equals(&op, "C"):
            http_header_list_combine(list, fetch_http_test_header(arguments[i], arguments[i + 1]))
            i += 2
            continue
        if ak.string_view_equals(&op, "D"):
            http_header_list_delete(list, arguments[i])
            i += 1
            continue

        if outputs > 0:
            ak.string_builder_append(builder, " ; ")
        outputs += 1
        if ak.string_view_equals(&op, "headers"):
            fetch_http_test_headers(builder, http_header_list_headers(list))
        elif ak.string_view_equals(&op, "contains"):
            fetch_http_test_bool(builder, http_header_list_contains(list, arguments[i]))
            i += 1
        elif ak.string_view_equals(&op, "get"):
            if let value = http_header_list_get(list, arguments[i]):
                ak.string_builder_append(builder, "\"")
                fetch_http_test_escape(builder, ak.byte_string_view(&value))
                ak.string_builder_append(builder, "\"")
            else:
                ak.string_builder_append(builder, "null")
            i += 1
        elif ak.string_view_equals(&op, "decode_split"):
            if let values = http_header_list_get_decode_and_split(list, arguments[i]):
                fetch_http_test_strings(builder, &values)
            else:
                ak.string_builder_append(builder, "null")
            i += 1
        elif ak.string_view_equals(&op, "extract_values"):
            match http_header_list_extract_header_list_values(list, arguments[i]):
                .empty: ak.string_builder_append(builder, "null")
                .http_header_list_extract_header_parse_failure(_): ak.string_builder_append(builder, "failure")
                .vector_byte_string(values): fetch_http_test_byte_strings(builder, &values)
            i += 1
        elif ak.string_view_equals(&op, "length"):
            match http_header_list_extract_length(list):
                .empty: ak.string_builder_append(builder, "null")
                .http_header_list_extract_length_failure(_): ak.string_builder_append(builder, "failure")
                .u64_(length): ak.format_u64(builder, length)
        elif ak.string_view_equals(&op, "content_range"):
            match http_header_list_extract_content_range_values(list):
                .http_header_list_extract_content_range_failure(_): ak.string_builder_append(builder, "failure")
                .http_header_list_content_range_values(range):
                    ak.format_u64(builder, range.first_byte_pos)
                    ak.string_builder_append(builder, "-")
                    ak.format_u64(builder, range.last_byte_pos)
                    ak.string_builder_append(builder, "/")
                    fetch_http_test_optional_u64(builder, range.complete_length)
        elif ak.string_view_equals(&op, "sort_combine"):
            let headers = http_header_list_sort_and_combine(list)
            fetch_http_test_headers(builder, &headers)
        elif ak.string_view_equals(&op, "unique"):
            let names = http_header_list_unique_names(list)
            fetch_http_test_byte_strings(builder, &names)
        elif ak.string_view_equals(&op, "mime"):
            fetch_http_test_mime(builder, fetch_extract_mime_type(list))
        elif ak.string_view_equals(&op, "legacy_encoding"):
            fetch_http_test_escape(builder, fetch_legacy_extract_an_encoding(fetch_extract_mime_type(list), arguments[i]))
            i += 1
        elif ak.string_view_equals(&op, "cors_unsafe_names"):
            let names = fetch_get_cors_unsafe_header_names(list)
            fetch_http_test_byte_strings(builder, &names)
        elif ak.string_view_equals(&op, "vary"):
            var values = ak.Vector[ak.ByteString]()
            http_header_list_for_each_vary_header(list, ak.Function1[ak.StringView, ak.IterationDecision](call = fetch_http_test_collect_vary, context = &values))
            fetch_http_test_byte_strings(builder, &values)
        else:
            trap("unknown header_list op")

## `std::stoull` of a case argument.
func fetch_http_test_u64(argument: ak.StringView) -> u64:
    return ak.string_view_to_number_u64(&argument) else trap("not a number")

## A URL of a case (`URL::Parser::basic_parse(...).release_value()`).
func fetch_http_test_url(argument: ak.StringView) -> web_url.Url:
    return web_url.parser_basic_parse(argument) else trap("the test URL parses")

## The oracle's `origin_of`: "client", "opaque" or the origin of a URL.
func fetch_http_test_origin(argument: ak.StringView) -> FetchRequestOriginType:
    if ak.string_view_equals(&argument, "client"):
        return .fetch_request_origin(FetchRequestOrigin.client)
    if ak.string_view_equals(&argument, "opaque"):
        return .origin(web_url.origin_create_opaque())
    let url = fetch_http_test_url(argument)
    return .origin(web_url.url_origin(&url))

## The oracle's `taint_name`.
func fetch_http_test_taint_name(taint: FetchRedirectTaint) -> str:
    match taint:
        .same_origin: return "same-origin"
        .same_site: return "same-site"
        .cross_site: return "cross-site"
        _: trap("unknown taint")

## The oracle's `mode_of`.
func fetch_http_test_mode(argument: ak.StringView) -> FetchRequestMode:
    if ak.string_view_equals(&argument, "same-origin"):
        return FetchRequestMode.same_origin
    if ak.string_view_equals(&argument, "cors"):
        return FetchRequestMode.cors
    if ak.string_view_equals(&argument, "no-cors"):
        return FetchRequestMode.no_cors
    if ak.string_view_equals(&argument, "navigate"):
        return FetchRequestMode.navigate
    return FetchRequestMode.web_socket

## The oracle's `tainting_of`.
func fetch_http_test_tainting(argument: ak.StringView) -> FetchRequestResponseTainting:
    if ak.string_view_equals(&argument, "basic"):
        return FetchRequestResponseTainting.basic
    if ak.string_view_equals(&argument, "cors"):
        return FetchRequestResponseTainting.cors
    return FetchRequestResponseTainting.opaque

## The oracle's `type_name`.
func fetch_http_test_type_name(type_: FetchResponseType) -> str:
    match type_:
        .basic: return "basic"
        .cors: return "cors"
        .default: return "default"
        .error_: return "error"
        .opaque: return "opaque"
        .opaque_redirect: return "opaqueredirect"
        _: trap("unknown type")

## The URL list of a case's arguments from `first` on.
func fetch_http_test_url_list(arguments: const ak.StringView[], first: usize) -> ak.Vector[web_url.Url]:
    var urls = ak.Vector[web_url.Url]()
    for argument in arguments[first..]:
        ak.vector_append_t(&urls, fetch_http_test_url(argument))
    return urls

## The oracle's `describe_response`.
func fetch_http_test_describe_response(builder: ak.StringBuilder*, response: FetchResponse*):
    ak.string_builder_append(builder, fetch_http_test_type_name(fetch_response_type(response)))
    ak.string_builder_append(builder, " ; ")
    ak.format_u64(builder, fetch_response_status(response))
    ak.string_builder_append(builder, " ; \"")
    let status_message = fetch_response_status_message(response)
    fetch_http_test_escape(builder, ak.byte_string_view(&status_message))
    ak.string_builder_append(builder, "\" ; ")
    fetch_http_test_headers(builder, http_header_list_headers(fetch_response_header_list(response)))
    ak.string_builder_append(builder, " ; ")
    ak.format_u64(builder, (u64)ak.vector_size(fetch_response_url_list_const(response)))
    ak.string_builder_append(builder, " ; ")
    if let url = fetch_response_url(response):
        let serialized = web_url.url_serialize(&url)
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
    else:
        ak.string_builder_append(builder, "null")
    let flags: bool[6] = [fetch_response_body(response) == none, fetch_response_is_network_error(response), fetch_response_is_aborted_network_error(response), fetch_response_is_cors_same_origin(response), fetch_response_is_cors_cross_origin(response), fetch_response_aborted(response)]
    for flag in flags:
        ak.string_builder_append(builder, " ; ")
        fetch_http_test_bool(builder, flag)
    ak.string_builder_append(builder, " ; ")
    if let message = fetch_response_network_error_message(response):
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&message))
    else:
        ak.string_builder_append(builder, "null")

## The oracle's request and response operations, with `vm`; false when `op` is not one of them.
func fetch_http_test_run_cells(builder: ak.StringBuilder*, vm: Vm*, op: str, a: const ak.StringView[]) -> bool:
    if op == "request_taint":
        let request = fetch_request_create(vm)
        fetch_request_set_origin(request, fetch_http_test_origin(a[0]))
        fetch_request_set_url_list(request, fetch_http_test_url_list(a, 1))
        let serialized = fetch_request_serialize_origin(request)
        let byte_serialized = fetch_request_byte_serialize_origin(request)
        ak.string_builder_append(builder, fetch_http_test_taint_name(fetch_request_redirect_taint(request)))
        ak.string_builder_append(builder, " ; ")
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
        ak.string_builder_append(builder, " ; ")
        fetch_http_test_escape(builder, ak.byte_string_view(&byte_serialized))
    elif op == "request_origin_header":
        let request = fetch_request_create(vm)
        fetch_request_set_method(request, ak.byte_string_from_string_view(a[0]))
        fetch_request_set_mode(request, fetch_http_test_mode(a[1]))
        fetch_request_set_response_tainting(request, fetch_http_test_tainting(a[2]))
        fetch_request_set_referrer_policy(request, referrer_policy_from_string(a[3]) else trap("a referrer policy"))
        fetch_request_set_origin(request, fetch_http_test_origin(a[4]))
        fetch_request_set_url_list(request, fetch_http_test_url_list(a, 5))
        fetch_request_add_origin_header(request)
        fetch_http_test_headers(builder, http_header_list_headers(fetch_request_header_list(request)))
    elif op == "request_range":
        let request = fetch_request_create(vm)
        var last: u64? = none
        if not ak.string_view_equals(&a[1], "null"):
            last = fetch_http_test_u64(a[1])
        fetch_request_add_range_header(request, fetch_http_test_u64(a[0]), last)
        fetch_http_test_headers(builder, http_header_list_headers(fetch_request_header_list(request)))
    elif op == "request_destinations":
        for d: i32 in -1..=(i32)FetchRequestDestination.xslt:
            let request = fetch_request_create(vm)
            if d >= 0:
                ak.string_builder_append(builder, " ; ")
                fetch_request_set_destination(request, FetchRequestDestination(d))
                ak.string_builder_append_string_view(builder, fetch_request_destination_to_string(FetchRequestDestination(d)))
            else:
                ak.string_builder_append(builder, "(empty)")
            ak.string_builder_append(builder, ":")
            ak.string_builder_append(builder, "s" if fetch_request_is_subresource_request(request) else "-")
            ak.string_builder_append(builder, "n" if fetch_request_is_non_subresource_request(request) else "-")
            ak.string_builder_append(builder, "v" if fetch_request_is_navigation_request(request) else "-")
            ak.string_builder_append(builder, "j" if fetch_request_destination_is_script_like(request) else "-")
    elif op == "translate_potential_destination":
        if let destination = fetch_translate_potential_destination(a[0]):
            ak.string_builder_append_string_view(builder, fetch_request_destination_to_string(destination))
        else:
            ak.string_builder_append(builder, "null")
    elif op == "request_modes":
        for m: i32 in 0..=(i32)FetchRequestMode.web_socket:
            if m > 0:
                ak.string_builder_append(builder, " ; ")
            ak.string_builder_append_string_view(builder, fetch_request_mode_to_string(FetchRequestMode(m)))
    elif op == "initiator_types":
        for t: i32 in 0..=(i32)FetchRequestInitiatorType.other:
            if t > 0:
                ak.string_builder_append(builder, " ; ")
            let type_ = fetch_initiator_type_to_string(FetchRequestInitiatorType(t))
            ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&type_))
    elif op == "priority":
        if let priority = fetch_request_priority_from_string(a[0]):
            match priority:
                .high: ak.string_builder_append(builder, "high")
                .low: ak.string_builder_append(builder, "low")
                _: ak.string_builder_append(builder, "auto")
        else:
            ak.string_builder_append(builder, "null")
    elif op == "response_filter":
        let internal = fetch_infrastructure_response_create(vm)
        var urls = ak.Vector[web_url.Url]()
        ak.vector_append_t(&urls, fetch_http_test_url(ak.sv("https://a.test/x")))
        ak.vector_append_t(&urls, fetch_http_test_url(ak.sv("https://b.test/y")))
        fetch_response_set_url_list(internal, urls)
        fetch_response_set_status_message(internal, ak.byte_string_from_str("OK"))
        var exposed = ak.Vector[ak.ByteString]()
        if not ak.string_view_equals(&a[1], "-"):
            var names = ak.string_view_split_view_u8(&a[1], ',')
            for name in ak.vector_span(&names):
                ak.vector_append_t(&exposed, ak.byte_string_from_string_view(name))
        fetch_response_set_cors_exposed_header_name_list(internal, exposed)
        var i: usize = 2
        while i + 1 < a.length:
            http_header_list_append(fetch_response_header_list(internal), fetch_http_test_header(a[i], a[i + 1]))
            i += 2
        var response = internal
        if ak.string_view_equals(&a[0], "basic"):
            response = (FetchResponse*)fetch_basic_filtered_response_create(vm, internal)
        elif ak.string_view_equals(&a[0], "cors"):
            response = (FetchResponse*)fetch_cors_filtered_response_create(vm, internal)
        elif ak.string_view_equals(&a[0], "opaque"):
            response = (FetchResponse*)fetch_opaque_filtered_response_create(vm, internal)
        elif ak.string_view_equals(&a[0], "opaqueredirect"):
            response = (FetchResponse*)fetch_opaque_redirect_filtered_response_create(vm, internal)
        fetch_http_test_describe_response(builder, response)
        ak.string_builder_append(builder, " ; ")
        fetch_http_test_bool(builder, fetch_response_unsafe_response(response) == internal)
    elif op == "network_error":
        if ak.string_view_equals(&a[0], "aborted"):
            fetch_http_test_describe_response(builder, fetch_response_aborted_network_error(vm))
        else:
            fetch_http_test_describe_response(builder, fetch_response_network_error(vm, ak.string_from_str("Something failed")))
    elif op == "location":
        let response = fetch_infrastructure_response_create(vm)
        fetch_response_set_status(response, u16(fetch_http_test_u64(a[0])))
        if not ak.string_view_equals(&a[1], "-"):
            fetch_response_set_url_list(response, fetch_http_test_url_list(a[1..<2], 0))
        var fragment: ak.String? = none
        if not ak.string_view_equals(&a[2], "-"):
            fragment = ak.string_from_utf8(a[2]) else trap("MUST: String::from_utf8")
        for location in a[3..]:
            http_header_list_append(fetch_response_header_list(response), http_header_create(ak.sv("Location"), location))
        let result = fetch_response_location_url(response, fragment) catch:
            ak.string_builder_append(builder, "failure")
            return true
        if let location = result:
            let serialized = web_url.url_serialize(&location)
            fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
        else:
            ak.string_builder_append(builder, "null")
    else:
        return false
    return true

## The oracle's `run`: the result line of one case.
func fetch_http_test_run(builder: ak.StringBuilder*, vm: Vm*, test_case: const FetchHttpCase*):
    let vector = fetch_http_test_arguments(test_case)
    let a = ak.vector_span_const(&vector)
    let op = test_case.op
    if fetch_http_test_run_cells(builder, vm, op, a):
        return
    if op == "is_header_name":
        fetch_http_test_bool(builder, http_is_header_name(a[0]))
    elif op == "is_header_value":
        fetch_http_test_bool(builder, http_is_header_value(a[0]))
    elif op == "normalize_header_value":
        ak.string_builder_append(builder, "\"")
        fetch_http_test_escape(builder, http_normalize_header_value(a[0]))
        ak.string_builder_append(builder, "\"")
    elif op == "is_forbidden_request_header":
        let header = fetch_http_test_header(a[0], a[1])
        fetch_http_test_bool(builder, http_is_forbidden_request_header(&header))
    elif op == "is_forbidden_response_header_name":
        fetch_http_test_bool(builder, http_is_forbidden_response_header_name(a[0]))
    elif op == "decode_split":
        let values = http_get_decode_and_split_header_value(a[0])
        fetch_http_test_strings(builder, &values)
    elif op == "extract_header_values":
        let header = fetch_http_test_header(a[0], a[1])
        if let values = http_header_extract_header_values(&header):
            fetch_http_test_byte_strings(builder, &values)
        else:
            ak.string_builder_append(builder, "failure")
    elif op == "sorted_lowercase_set":
        var names = ak.Vector[ak.ByteString]()
        for argument in a:
            ak.vector_append_t(&names, ak.byte_string_from_string_view(argument))
        let set = http_convert_header_names_to_a_sorted_lowercase_set(ak.vector_span_const(&names))
        fetch_http_test_byte_strings(builder, &set)
    elif op == "build_content_range":
        let range = http_build_content_range(fetch_http_test_u64(a[0]), fetch_http_test_u64(a[1]), fetch_http_test_u64(a[2]))
        fetch_http_test_escape(builder, ak.byte_string_view(&range))
    elif op == "parse_single_range":
        if let range = http_parse_single_range_header_value(a[0], ak.string_view_equals(&a[1], "1")):
            fetch_http_test_optional_u64(builder, range.start)
            ak.string_builder_append(builder, "-")
            fetch_http_test_optional_u64(builder, range.end)
        else:
            ak.string_builder_append(builder, "failure")
    elif op == "isomorphic_encode":
        let header = http_header_isomorphic_encode(a[0], a[1])
        ak.string_builder_append(builder, "(")
        fetch_http_test_escape(builder, ak.byte_string_view(&header.name))
        ak.string_builder_append(builder, ": ")
        fetch_http_test_escape(builder, ak.byte_string_view(&header.value))
        ak.string_builder_append(builder, ")")
    elif op == "is_method":
        fetch_http_test_bool(builder, http_is_method(a[0]))
    elif op == "is_cors_safelisted_method":
        fetch_http_test_bool(builder, http_is_cors_safelisted_method(a[0]))
    elif op == "is_forbidden_method":
        fetch_http_test_bool(builder, http_is_forbidden_method(a[0]))
    elif op == "normalize_method":
        let method = http_normalize_method(a[0])
        fetch_http_test_escape(builder, ak.byte_string_view(&method))
    elif op == "reason_phrase":
        fetch_http_test_escape(builder, http_reason_phrase_for_code(u32(fetch_http_test_u64(a[0]))))
    elif op == "token_code_points":
        for code_point: u32 in 0..<256:
            ak.string_builder_append(builder, "1" if http_is_http_token_code_point(code_point) else "0")
    elif op == "header_list":
        fetch_http_test_header_list(builder, a)
    elif op == "cors_safelisted_request_header":
        let header = fetch_http_test_header(a[0], a[1])
        fetch_http_test_bool(builder, fetch_is_cors_safelisted_request_header(&header))
    elif op == "cors_unsafe_bytes":
        for byte: u32 in 0..<256:
            ak.string_builder_append(builder, "1" if fetch_is_cors_unsafe_request_header_byte((u8)byte) else "0")
    elif op == "cors_non_wildcard":
        fetch_http_test_bool(builder, fetch_is_cors_non_wildcard_request_header_name(a[0]))
    elif op == "privileged_no_cors":
        fetch_http_test_bool(builder, fetch_is_privileged_no_cors_request_header_name(a[0]))
    elif op == "cors_safelisted_response_header_name":
        fetch_http_test_bool(builder, fetch_is_cors_safelisted_response_header_name(a[0], a[1..]))
    elif op == "no_cors_safelisted_name":
        fetch_http_test_bool(builder, fetch_is_no_cors_safelisted_request_header_name(a[0]))
    elif op == "no_cors_safelisted_header":
        let header = fetch_http_test_header(a[0], a[1])
        fetch_http_test_bool(builder, fetch_is_no_cors_safelisted_request_header(&header))
    elif op == "statuses":
        ak.string_builder_append(builder, "null:")
        for status: u16 in 0..<1000:
            if fetch_is_null_body_status(status):
                ak.string_builder_append(builder, " ")
                ak.format_u64(builder, status)
        ak.string_builder_append(builder, " ; ok:")
        for status: u16 in 0..<1000:
            if fetch_is_ok_status(status):
                ak.string_builder_append(builder, " ")
                ak.format_u64(builder, status)
        ak.string_builder_append(builder, " ; redirect:")
        for status: u16 in 0..<1000:
            if fetch_is_redirect_status(status):
                ak.string_builder_append(builder, " ")
                ak.format_u64(builder, status)
    else:
        trap("unknown op")

test "LibHTTP and Fetch/Infrastructure/HTTP give the reference build's results":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var failures = 0
    for test_case in &fetch_http_cases:
        var builder = ak.string_builder_new()
        fetch_http_test_run(&builder, vm, test_case)
        let result = ak.string_builder_string_view(&builder)
        if not ak.string_view_eq_string_view(&result, ak.string_view_from_bytes(test_case.expected)):
            var arguments = ak.string_builder_new()
            fetch_http_test_escape(&arguments, ak.string_view_from_bytes(test_case.arguments))
            print(f"{test_case.op} {ak.string_view_text(ak.string_builder_string_view(&arguments))}:\n  expected {(str)test_case.expected}\n  got      {ak.string_view_text(result)}")
            failures += 1
    assert(failures == 0)