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)