Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / loader / tests_loader_2.lucb

#==============================================================================================
#
#   tests_loader_2 - the LibCore seams, LoadRequest, ResourceLoader's settings and its
#   in-process loads, and the in-process RequestClient's file: and data: requests
#
#   DESCRIPTION:
#       Ladybird has no unit tests for these; they pin the C++ behaviour: Core::Promise's
#       handlers (set before or after it settles) and await; Core::Resource over file:// and
#       resource:// (data/res); the generated directory page; LoadRequest's accessors and
#       timer; ResourceLoader's initialization, its settings kept in the C heap, and load's
#       blocked, unsupported, resource:, file: (through PageClient::request_file) and missing
#       page cases; the RequestClient seam with the in-process client's data: and file:
#       requests, stopping one, and PageClient::request_file's descriptor.
#
#==============================================================================================

# mark: Core::Promise ===========================================================================

## What a promise's handlers heard.
struct LoaderTestPromiseLog:
    var resolved: i32
    var rejected: i32
    var value: i32
    var error_code: i32

    static func on_resolved(context: void*?, value: i32*):
        let log = (LoaderTestPromiseLog*)(context else trap("no log"))
        log.resolved += 1
        log.value = *value

    static func on_rejected(context: void*?, error_: ak.AkError*):
        let log = (LoaderTestPromiseLog*)(context else trap("no log"))
        log.rejected += 1
        log.error_code = ak.ak_error_code(error_)

## The deferred invocation that resolves a promise with 7.
func loader_test_resolve_later(context: void*?):
    core_promise_resolve((CorePromise[i32, ak.AkError]*)(context else trap("no promise")), 7)

test "Core::Promise: handlers set before or after it settles hear it once; await pumps the loop":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var log = LoaderTestPromiseLog()
    let resolved_handler = ak.Function1[i32*, unit](call = LoaderTestPromiseLog.on_resolved, context = &log)
    let rejected_handler = ak.Function1[ak.AkError*, unit](call = LoaderTestPromiseLog.on_rejected, context = &log)

    # Handlers first, then the result.
    let first = core_promise_construct[i32, ak.AkError]()
    assert(not core_promise_is_resolved(first) and not core_promise_is_rejected(first))
    _ = core_promise_when_resolved(first, resolved_handler)
    _ = core_promise_when_rejected(first, rejected_handler)
    core_promise_resolve(first, 42)
    assert(log.resolved == 1 and log.value == 42 and log.rejected == 0)
    assert(core_promise_is_resolved(first) and not core_promise_is_rejected(first))

    # The result first: when_resolved runs the handler at once; when_rejected does not.
    let second = core_promise_construct[i32, ak.AkError]()
    core_promise_resolve(second, 5)
    _ = core_promise_when_rejected(second, rejected_handler)
    _ = core_promise_when_resolved(second, resolved_handler)
    assert(log.resolved == 2 and log.value == 5 and log.rejected == 0)

    # A rejection: the rejection handler, before or after.
    let third = core_promise_construct[i32, ak.AkError]()
    _ = core_promise_when_rejected(third, rejected_handler)
    core_promise_reject(third, ak.ak_error_from_errno(2))
    assert(log.rejected == 1 and log.error_code == 2)
    assert(core_promise_is_rejected(third) and not core_promise_is_resolved(third))
    let fourth = core_promise_construct[i32, ak.AkError]()
    core_promise_reject(fourth, ak.ak_error_from_errno(13))
    _ = core_promise_when_resolved(fourth, resolved_handler)
    _ = core_promise_when_rejected(fourth, rejected_handler)
    assert(log.rejected == 2 and log.error_code == 13 and log.resolved == 2)

    # await pumps the event loop until the promise settles, and answers (and releases) the result.
    var event_loop = LoaderTestEventLoop()
    loader_test_install_event_loop(&event_loop)
    defer loader_test_remove_event_loop()
    let fifth = core_promise_construct[i32, ak.AkError]()
    core_deferred_invoke(ak.Function0[unit](call = loader_test_resolve_later, context = fifth))
    match core_promise_await(fifth):
        .value(value): assert(value == 7)
        .error_(_): trap("the promise resolved")
    assert(not core_promise_is_resolved(fifth))
    match core_promise_await(fourth):
        .value(_): trap("the promise was rejected")
        .error_(failure): assert(ak.ak_error_code(&failure) == 13)

# mark: Core::Resource ==========================================================================

test "Core::Resource: file:// and resource:// files and directories, their URIs, names and data":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    loader_test_install_resources()

    let template_uri = ak.sv("resource://ladybird/templates/error.html")
    let resource = core_resource_load_from_uri(template_uri) else trap("the error template loads")
    assert(core_resource_is_file(resource) and not core_resource_is_directory(resource))
    let uri = core_resource_uri(resource)
    assert(ak.string_eq_string_view(&uri, template_uri))
    let filesystem_path = core_resource_filesystem_path(resource)
    assert(ak.string_eq_string_view(&filesystem_path, ak.sv("data/res/ladybird/templates/error.html")))
    let file_url = core_resource_file_url(resource)
    assert(ak.string_eq_string_view(&file_url, ak.sv("file://data/res/ladybird/templates/error.html")))
    let filename = core_resource_filename(resource)
    assert(ak.string_eq_string_view(&filename, ak.sv("error.html")))
    assert(core_resource_modified_time(resource) != none)
    let data = core_resource_data(resource)
    assert(data.length == 1750 and data[0] == '<')
    let clone = core_resource_clone_data(resource)
    assert(ak.byte_buffer_size(&clone) == 1750)

    # A resource:// directory and its children.
    let directory = core_resource_load_from_uri(ak.sv("resource://ladybird/templates")) else trap("the templates directory loads")
    assert(core_resource_is_directory(directory))
    let children = core_resource_children(directory)
    assert(ak.vector_size(&children) == 2)
    assert(ak.string_eq_string_view(ak.vector_at_const(&children, 0), ak.sv("directory.html")))
    assert(ak.string_eq_string_view(ak.vector_at_const(&children, 1), ak.sv("error.html")))

    # A file:// file by its relative path, through load_from_filesystem (the working directory prepended).
    let same = core_resource_load_from_filesystem(ak.sv("data/res/ladybird/templates/error.html")) else trap("the template loads from the file system")
    assert(same.m_scheme == CoreResourceScheme.file and core_resource_data(same).length == 1750)
    let same_uri = core_resource_uri(same)
    let same_uri_view = ak.string_bytes_as_string_view(&same_uri)
    assert(ak.string_view_starts_with_string_view(&same_uri_view, ak.sv("file:///")))
    assert(ak.string_view_ends_with_string_view(&same_uri_view, ak.sv("/data/res/ladybird/templates/error.html")))

    # Errors: a missing file, an unknown scheme.
    let missing: CoreResource*? = core_resource_load_from_uri(ak.sv("resource://ladybird/templates/nope.html")) catch:
        recover none
    assert(missing == none)
    let unknown: CoreResource*? = core_resource_load_from_uri(ak.sv("ftp://x/y")) catch failure:
        assert(failure.code == ak.ak_error)
        recover none
    assert(unknown == none)

test "load_file_directory_page: the directory's entries sorted, folders and files, from the directory template":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    loader_test_install_resources()
    let cwd = core_system_getcwd() else trap("the working directory")
    var url_text = ak.string_builder_new()
    ak.string_builder_append(&url_text, "file://")
    ak.string_builder_append_string_view(&url_text, ak.byte_string_view(&cwd))
    ak.string_builder_append(&url_text, "/data/res/ladybird")
    let url = web_url.parser_basic_parse(ak.string_builder_string_view(&url_text)) else trap("the directory's URL")
    let page = load_file_directory_page(url) else trap("the directory page")
    let view = ak.string_bytes_as_string_view(&page)
    assert(ak.string_view_starts_with_string_view(&view, ak.sv("<!DOCTYPE html>"), ak.CaseSensitivity.case_insensitive))
    assert(ak.string_view_find_string_view(&view, ak.sv("<title>Index of ")) != none)
    let templates = ak.string_view_find_string_view(&view, ak.sv("<td><span class=\"folder\"></span></td><td><a href=\"file://")) else trap("the templates folder's row")
    let name = ak.string_view_find_string_view(&view, ak.sv("/data/res/ladybird/templates\">templates</a></td><td>&nbsp;</td><td>-         </td>")) else trap("its link and size")
    assert(name > templates)
    assert(ak.string_view_find_string_view(&view, ak.sv("Open Parent Directory")) != none)
    assert(ak.string_view_find_string_view(&view, ak.sv("%contents%")) == none)

# mark: LoadRequest =============================================================================

test "LoadRequest: GET by default, its setters, and the timer":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let headers = http_header_list_create()
    var request = load_request_create(headers)
    let method = load_request_method(&request)
    let method_view = ak.byte_string_view(&method)
    assert(ak.string_view_eq_string_view(&method_view, ak.sv("GET")))
    assert(load_request_url(&request) == none and load_request_page(&request) == none)
    assert(load_request_cache_mode(&request) == HttpCacheMode.default)
    assert(load_request_include_credentials(&request) == HttpIncludeCredentials.yes)
    assert(load_request_initiator_type(&request) == none)
    assert(load_request_headers(&request) == headers)
    let zero = load_request_load_time(&request)
    assert(ak.duration_to_milliseconds(&zero) == 0)
    load_request_set_url(&request, loader_test_url("https://example.com/"))
    load_request_set_method(&request, ak.byte_string_from_str("POST"))
    load_request_set_body(&request, ak.byte_buffer_copy_span_u8(b"abc") else trap("a body"))
    load_request_set_cache_mode(&request, HttpCacheMode.no_store)
    load_request_set_include_credentials(&request, HttpIncludeCredentials.no)
    load_request_set_initiator_type(&request, FetchRequestInitiatorType.img)
    assert(ak.byte_buffer_size(load_request_body(&request)) == 3)
    assert(load_request_cache_mode(&request) == HttpCacheMode.no_store and load_request_include_credentials(&request) == HttpIncludeCredentials.no)
    assert(load_request_initiator_type(&request) == FetchRequestInitiatorType.img)
    load_request_start_timer(&request)
    let elapsed = load_request_load_time(&request)
    assert(ak.duration_to_milliseconds(&elapsed) >= 0 and ak.duration_to_milliseconds(&elapsed) < 1000)

# mark: ResourceLoader ==========================================================================

## Whether `value` is `text`.
func loader_test_byte_string_is(value: ak.ByteString, text: str) -> bool:
    let view = ak.byte_string_view(&value)
    return ak.string_view_equals(&view, text)

## The vtable of the loader tests' PageClient: the test PageClient's (tests_page), whose request_file
## opens the file in process (in_process_request_file) and which counts the network notifications.
let loader_test_page_client_vtable: PageClientVTable = PageClientVTable(cell_vtable = JsCellVTable(cell_vtable = gc.CellVTable(class_info = &test_page_client_class, visit_edges = test_page_client_visit_edges)), id = test_page_client_id, page = test_page_client_page, page_const = test_page_client_page, is_connection_open = test_page_client_is_connection_open, zoom_level = test_page_client_one, device_pixel_ratio = test_page_client_one, device_pixels_per_css_pixel = test_page_client_one, preferred_color_scheme = test_page_client_preferred_color_scheme, preferred_contrast = test_page_client_preferred_contrast, preferred_motion = test_page_client_preferred_motion, request_frame = test_document_request_frame, page_did_change_title = test_document_page_did_change_title, display_list_player_type = test_page_client_display_list_player_type, is_headless = test_page_client_is_headless, palette = test_page_client_palette,
                                                                        request_file = loader_test_page_client_request_file, page_did_start_network_request = loader_test_page_client_started,
                                                                        page_did_finish_network_request = loader_test_page_client_finished)

## The network notifications the test PageClient heard.
var loader_test_network_started: i32
var loader_test_network_finished: i32

## The test PageClient's request_file.
func loader_test_page_client_request_file(this: PageClient*, file_request: FileRequest):
    in_process_request_file(file_request)

## The test PageClient's page_did_start_network_request.
func loader_test_page_client_started(this: PageClient*, request_id: u64, url: web_url.Url, method: ak.ByteString, request_headers: ak.Vector[HttpHeader],
                                     request_body: const u8[], initiator_type: ak.String?):
    loader_test_network_started += 1

## The test PageClient's page_did_finish_network_request.
func loader_test_page_client_finished(this: PageClient*, request_id: u64, body_size: u64, timing_info: RequestsRequestTimingInfo, network_error: RequestsNetworkError?):
    loader_test_network_finished += 1

## A page whose client is the loader tests' PageClient.
func loader_test_create_page(vm: Vm*) -> Page*:
    let page = web_test_create_page(vm)
    ((gc.Cell*)page_client(page)).vtable = (const gc.CellVTable*)&loader_test_page_client_vtable
    loader_test_network_started = 0
    loader_test_network_finished = 0
    return page

## What a load's callbacks heard (managed memory: the callbacks may run after the test's frame changed).
struct LoaderTestLoad:
    var headers: HttpHeaderList*?
    var status_code: u32?
    var reason_phrase: ak.String?
    var data: ak.ByteBuffer
    var completions: i32
    var success: bool
    var error_message: ak.ByteString?

    static func on_headers(context: void*?, headers: const HttpHeaderList*, status_code: u32?, reason_phrase: const (ak.String?)*):
        let load = (LoaderTestLoad*)(context else trap("no load"))
        load.headers = http_header_list_create(ak.vector_clone(http_header_list_headers(headers)))
        load.status_code = status_code
        load.reason_phrase = *reason_phrase

    static func on_data(context: void*?, data: const u8[]):
        let load = (LoaderTestLoad*)(context else trap("no load"))
        ak.byte_buffer_append_span_u8(&load.data, data)

    static func on_complete(context: void*?, success: bool, timing_info: const RequestsRequestTimingInfo*, error_message: ak.StringView?):
        let load = (LoaderTestLoad*)(context else trap("no load"))
        load.completions += 1
        load.success = success
        if let message = error_message:
            load.error_message = ak.byte_string_from_string_view(message)

    ## The value of a response header.
    func header(name: str) -> ak.ByteString?:
        let headers = self.headers else return none
        return http_header_list_get(headers, ak.sv(name))

## Starts loading `url` (with `page`, if any) through ResourceLoader::the(), its callbacks recording into a new LoaderTestLoad.
func loader_test_load(vm: Vm*, url: str, page: Page*?) -> (LoaderTestLoad*, RequestsRequest*?):
    let load = new LoaderTestLoad(data = ak.ByteBuffer()) else trap("out of memory")
    let heap = vm_heap(vm)
    var request = load_request_create(http_header_list_create())
    load_request_set_url(&request, loader_test_url(url))
    if let request_page = page:
        load_request_set_page(&request, request_page)
    let on_headers = gc.create_function3(heap, ak.Function3[const HttpHeaderList*, u32?, const (ak.String?)*, unit](call = LoaderTestLoad.on_headers, context = load))
    let on_data = gc.create_function1(heap, ak.Function1[const u8[], unit](call = LoaderTestLoad.on_data, context = load))
    let on_complete = gc.create_function3(heap, ak.Function3[bool, const RequestsRequestTimingInfo*, ak.StringView?, unit](call = LoaderTestLoad.on_complete, context = load))
    let protocol_request = resource_loader_load(resource_loader_the(), &request, on_headers, on_data, on_complete)
    return (load, protocol_request)

## Whether `load` failed with `message`.
func loader_test_failed_with(load: const LoaderTestLoad*, message: str) -> bool:
    let error_message = load.error_message else return false
    let view = ak.byte_string_view(&error_message)
    return load.completions == 1 and not load.success and ak.string_view_equals(&view, message)

## Whether the bytes `load` received are `text`.
func loader_test_received(load: const LoaderTestLoad*, text: str) -> bool:
    let view = ak.string_view_from_bytes(ak.byte_buffer_bytes_const(&load.data))
    return ak.string_view_equals(&view, text)

## The loader of a test: an in-process client in the VM's heap, ResourceLoader::initialize with it.
func loader_test_initialize_resource_loader(vm: Vm*) -> InProcessRequestClient*:
    let client = in_process_request_client_create(vm_heap(vm))
    resource_loader_initialize(vm_heap(vm), &client.client)
    return client

test "ResourceLoader: initialize, the defaults of its settings, and the setters' copies in the C heap":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let client = loader_test_initialize_resource_loader(vm)
    assert(resource_loader_is_initialized())
    let loader = resource_loader_the()
    assert(resource_loader_class_name(loader).m_length == 14)
    assert(*resource_loader_request_client(loader) == &client.client)
    assert(resource_loader_pending_loads(loader) == 0)
    let user_agent = resource_loader_user_agent()
    assert(ak.string_eq_string_view(&user_agent, ak.sv(default_user_agent)))
    let platform = resource_loader_platform()
    assert(ak.string_eq_string_view(&platform, ak.sv(default_platform)))
    assert(ak.vector_size(resource_loader_preferred_languages()) == 1)
    assert(ak.string_eq_string_view(ak.vector_at_const(resource_loader_preferred_languages(), 0), ak.sv("en-US")))
    assert(resource_loader_navigator_compatibility_mode() == NavigatorCompatibilityMode.chrome)
    assert(not resource_loader_enable_global_privacy_control(loader))

    resource_loader_set_user_agent(loader, ak.string_from_str("Test agent, a string longer than a short string"))
    resource_loader_set_platform(loader, ak.string_from_str("Test platform"))
    var languages: ak.Vector[ak.String]
    ak.vector_append_t(&languages, ak.string_from_str("fr-CA, a long language tag"))
    ak.vector_append_t(&languages, ak.string_from_str("fr"))
    resource_loader_set_preferred_languages(loader, languages)
    resource_loader_set_navigator_compatibility_mode(loader, NavigatorCompatibilityMode.gecko)
    resource_loader_set_enable_global_privacy_control(loader, true)
    # The values outlive collections of the VM's heap: the loader keeps C-heap copies.
    gc.heap_collect_garbage(vm_heap(vm))
    let new_agent = resource_loader_user_agent()
    assert(ak.string_eq_string_view(&new_agent, ak.sv("Test agent, a string longer than a short string")))
    let new_platform = resource_loader_platform()
    assert(ak.string_eq_string_view(&new_platform, ak.sv("Test platform")))
    assert(ak.vector_size(resource_loader_preferred_languages()) == 2)
    assert(ak.string_eq_string_view(ak.vector_at_const(resource_loader_preferred_languages(), 0), ak.sv("fr-CA, a long language tag")))
    assert(resource_loader_navigator_compatibility_mode() == NavigatorCompatibilityMode.gecko)
    assert(resource_loader_enable_global_privacy_control(loader))

    # The client's death forgets it; set_client installs another.
    ak.function0_call(&client.client.on_request_server_died)
    assert(*resource_loader_request_client(loader) == none)
    resource_loader_set_client(loader, &client.client)
    assert(*resource_loader_request_client(loader) == &client.client)

test "ResourceLoader::load: blocked ports and filtered URLs, unsupported schemes, file: without a page":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var event_loop = LoaderTestEventLoop()
    loader_test_install_event_loop(&event_loop)
    defer loader_test_remove_event_loop()
    _ = loader_test_initialize_resource_loader(vm)

    let (blocked, blocked_request) = loader_test_load(vm, "http://example.com:25/", none)
    assert(blocked_request == none and loader_test_failed_with(blocked, "Request was blocked"))

    let patterns = loader_test_patterns("blocked.test")
    content_filter_set_patterns(content_filter_the(), ak.vector_span_const(&patterns)) else trap("set_patterns")
    defer loader_test_reset_globals()
    let (filtered, filtered_request) = loader_test_load(vm, "https://blocked.test/a.png", none)
    assert(filtered_request == none and loader_test_failed_with(filtered, "Request was blocked"))

    let (unsupported, unsupported_request) = loader_test_load(vm, "ftp://example.com:2121/file", none)
    assert(unsupported_request == none and loader_test_failed_with(unsupported, "Protocol not implemented: ftp"))

    let (no_page, no_page_request) = loader_test_load(vm, "file:///tmp/x.html", none)
    assert(no_page_request == none and loader_test_failed_with(no_page, "INTERNAL ERROR: No Page for file scheme request"))
    assert(ak.vector_is_empty(&event_loop.deferred))

test "ResourceLoader::load: resource: files and directories, file: through PageClient::request_file":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var event_loop = LoaderTestEventLoop()
    loader_test_install_event_loop(&event_loop)
    defer loader_test_remove_event_loop()
    _ = loader_test_initialize_resource_loader(vm)
    loader_test_install_resources()

    # resource: loads answer at once, with the guessed Content-Type and the file's Last-Modified.
    let (resource, resource_request) = loader_test_load(vm, "resource://ladybird/templates/error.html", none)
    assert(resource_request == none and resource.completions == 1 and resource.success)
    assert(resource.status_code == none and resource.reason_phrase == none)
    let content_type = resource.header("Content-Type") else trap("a Content-Type")
    assert(loader_test_byte_string_is(content_type, "text/html"))
    let allow_origin = resource.header("Access-Control-Allow-Origin") else trap("an Access-Control-Allow-Origin")
    assert(loader_test_byte_string_is(allow_origin, "null"))
    assert(resource.header("Last-Modified") != none)
    assert(ak.byte_buffer_size(&resource.data) == 1750)
    let (missing, _) = loader_test_load(vm, "resource://ladybird/templates/nope.html", none)
    assert(missing.completions == 1 and not missing.success and missing.error_message != none)

    # file: asks the page's client to open the file, and answers on a later turn of the event loop.
    let page = loader_test_create_page(vm)
    let cwd = core_system_getcwd() else trap("the working directory")
    var file_url = ak.string_builder_new()
    ak.string_builder_append(&file_url, "file://")
    ak.string_builder_append_string_view(&file_url, ak.byte_string_view(&cwd))
    ak.string_builder_append(&file_url, "/data/res/ladybird/templates/directory.html")
    let file_url_text = ak.string_builder_to_byte_string(&file_url)
    let (file, file_request) = loader_test_load(vm, ak.string_view_text(ak.byte_string_view(&file_url_text)), page)
    assert(file_request == none and file.completions == 0)
    assert(resource_loader_pending_loads(resource_loader_the()) == 1)
    loader_test_drain(&event_loop)
    assert(resource_loader_pending_loads(resource_loader_the()) == 0)
    assert(file.completions == 1 and file.success and ak.byte_buffer_size(&file.data) == 1590)
    let file_type = file.header("Content-Type") else trap("a Content-Type")
    assert(loader_test_byte_string_is(file_type, "text/html"))

    # A missing file: the client's error; a directory: its generated page.
    let (missing_file, _) = loader_test_load(vm, "file:///nonexistent/p2d/missing.html", page)
    loader_test_drain(&event_loop)
    assert(loader_test_failed_with(missing_file, "No such file or directory (errno=2)"))
    var directory_url = ak.string_builder_new()
    ak.string_builder_append(&directory_url, "file://")
    ak.string_builder_append_string_view(&directory_url, ak.byte_string_view(&cwd))
    ak.string_builder_append(&directory_url, "/data/res/ladybird")
    let directory_url_text = ak.string_builder_to_byte_string(&directory_url)
    let (directory, _) = loader_test_load(vm, ak.string_view_text(ak.byte_string_view(&directory_url_text)), page)
    loader_test_drain(&event_loop)
    assert(directory.completions == 1 and directory.success)
    let directory_view = ak.string_view_from_bytes(ak.byte_buffer_bytes_const(&directory.data))
    assert(ak.string_view_find_string_view(&directory_view, ak.sv(">templates</a>")) != none)
    # (No network request was made, so the page heard of none.)
    assert(loader_test_network_started == 0 and loader_test_network_finished == 0)

# mark: The in-process RequestClient: data: and file: ==========================================

## What a request of the seam delivered.
struct LoaderTestSeamLog:
    var headers: HttpHeaderList*?
    var status_code: u32?
    var reason_phrase: ak.String?
    var data: ak.ByteBuffer
    var finishes: i32
    var total_size: u64
    var network_error: RequestsNetworkError?
    ## How many chunks of the body came, and whether anything came out of order (data before the headers, anything
    ## after the end).
    var chunks: i32
    var out_of_order: bool

    static func on_headers(context: void*?, headers: HttpHeaderList*, status_code: u32?, reason_phrase: ak.String?):
        let log = (LoaderTestSeamLog*)(context else trap("no log"))
        if log.headers != none or log.finishes > 0:
            log.out_of_order = true
        log.headers = headers
        log.status_code = status_code
        log.reason_phrase = reason_phrase

    static func on_data(context: void*?, data: const u8[]):
        let log = (LoaderTestSeamLog*)(context else trap("no log"))
        if log.headers == none or log.finishes > 0:
            log.out_of_order = true
        log.chunks += 1
        ak.byte_buffer_append_span_u8(&log.data, data)

    static func on_finish(context: void*?, total_size: u64, timing_info: RequestsRequestTimingInfo, network_error: RequestsNetworkError?):
        let log = (LoaderTestSeamLog*)(context else trap("no log"))
        log.finishes += 1
        log.total_size = total_size
        log.network_error = network_error

    ## The value of a response header.
    func header(name: str) -> ak.ByteString?:
        let headers = self.headers else return none
        return http_header_list_get(headers, ak.sv(name))

    ## Whether the body received is `text`.
    func received(text: str) -> bool:
        let view = ak.string_view_from_bytes(ak.byte_buffer_bytes_const(&self.data))
        return ak.string_view_equals(&view, text)

## Starts a GET of `url` through `client`, its deliveries recorded in a new log.
func loader_test_start(client: InProcessRequestClient*, url: str, method: str = "GET", headers: HttpHeaderList*? = none, body: const u8[] = b"") -> (LoaderTestSeamLog*, RequestsRequest*):
    let log = new LoaderTestSeamLog(data = ak.ByteBuffer()) else trap("out of memory")
    let request = requests_request_client_start_request(&client.client, ak.byte_string_from_str(method), loader_test_url(url), headers, body) else trap("the request starts")
    requests_request_set_unbuffered_request_callbacks(request, ak.Function3[HttpHeaderList*, u32?, ak.String?, unit](call = LoaderTestSeamLog.on_headers, context = log),
                                                      ak.Function1[const u8[], unit](call = LoaderTestSeamLog.on_data, context = log),
                                                      ak.Function3[u64, RequestsRequestTimingInfo, RequestsNetworkError?, unit](call = LoaderTestSeamLog.on_finish, context = log))
    return (log, request)

test "the in-process RequestClient: data: and file: requests on the event loop, ids, stopping one":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var event_loop = LoaderTestEventLoop()
    loader_test_install_event_loop(&event_loop)
    defer loader_test_remove_event_loop()
    let client = in_process_request_client_create(vm_heap(vm))

    let (data_log, data_request) = loader_test_start(client, "data:text/plain;charset=utf-8,hello%20world")
    let (base64_log, base64_request) = loader_test_start(client, "data:image/png;base64,iVBORw0KGgo=")
    assert(requests_request_id(data_request) == 0 and requests_request_id(base64_request) == 1)
    assert(data_request.m_mode == RequestsRequestMode.unbuffered)
    # Nothing is delivered before the event loop runs the requests.
    assert(data_log.finishes == 0 and data_log.headers == none)
    loader_test_drain(&event_loop)
    assert(data_log.finishes == 1 and data_log.network_error == none and data_log.status_code == 200)
    assert(data_log.received("hello world") and data_log.total_size == 11)
    let data_type = data_log.header("Content-Type") else trap("a Content-Type")
    assert(loader_test_byte_string_is(data_type, "text/plain;charset=utf-8"))
    assert(base64_log.finishes == 1 and ak.byte_buffer_size(&base64_log.data) == 8)

    # A bad data: URL, a missing file, an unknown scheme: a network error, no headers.
    let (bad_log, _) = loader_test_start(client, "data:text/html;base64,%%%")
    let (missing_log, _) = loader_test_start(client, "file:///nonexistent/p2d/missing.html")
    let (gopher_log, _) = loader_test_start(client, "gopher://example.com/")
    loader_test_drain(&event_loop)
    assert(bad_log.finishes == 1 and bad_log.network_error == RequestsNetworkError.malformed_url and bad_log.headers == none)
    assert(missing_log.finishes == 1 and missing_log.network_error == RequestsNetworkError.unknown)
    assert(gopher_log.finishes == 1 and gopher_log.network_error == RequestsNetworkError.malformed_url)

    # A file: its bytes and the headers ResourceLoader gives a file.
    let cwd = core_system_getcwd() else trap("the working directory")
    var file_url = ak.string_builder_new()
    ak.string_builder_append(&file_url, "file://")
    ak.string_builder_append_string_view(&file_url, ak.byte_string_view(&cwd))
    ak.string_builder_append(&file_url, "/data/res/ladybird/templates/error.html")
    let file_url_text = ak.string_builder_to_byte_string(&file_url)
    let (file_log, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&file_url_text)))
    loader_test_drain(&event_loop)
    assert(file_log.finishes == 1 and file_log.network_error == none and ak.byte_buffer_size(&file_log.data) == 1750)
    let file_type = file_log.header("Content-Type") else trap("a Content-Type")
    assert(loader_test_byte_string_is(file_type, "text/html"))

    # A stopped request delivers nothing more; stopping it again, or a finished one, answers false.
    let (stopped_log, stopped_request) = loader_test_start(client, "data:,never")
    assert(requests_request_stop(stopped_request))
    assert(not requests_request_stop(stopped_request))
    loader_test_drain(&event_loop)
    assert(stopped_log.finishes == 0 and stopped_log.headers == none and ak.byte_buffer_size(&stopped_log.data) == 0)
    assert(not requests_request_stop(data_request))

## What PageClient::request_file's callback heard.
struct LoaderTestFileResult:
    var calls: i32
    var result: ErrorOrI32

    static func call(context: void*?, result: ErrorOrI32):
        let log = (LoaderTestFileResult*)(context else trap("no log"))
        log.calls += 1
        log.result = result

test "in_process_request_file: a descriptor of the open file on the next turn of the event loop, or the error":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    var event_loop = LoaderTestEventLoop()
    loader_test_install_event_loop(&event_loop)
    defer loader_test_remove_event_loop()

    let found = new LoaderTestFileResult(result = ErrorOrI32.value(value = -1)) else trap("out of memory")
    var request = FileRequest(m_path = ak.byte_string_empty())
    file_request_construct(&request, ak.byte_string_from_str("data/res/ladybird/templates/error.html"), ak.Function1[ErrorOrI32, unit](call = LoaderTestFileResult.call, context = found))
    let path = file_request_path(&request)
    assert(loader_test_byte_string_is(path, "data/res/ladybird/templates/error.html"))
    in_process_request_file(request)
    assert(found.calls == 0)
    loader_test_drain(&event_loop)
    assert(found.calls == 1)
    match found.result:
        .value(fd):
            assert(fd >= 0)
            let st = core_system_fstat(fd) else trap("fstat")
            assert(not core_system_is_directory(&st) and st.size == 1750)
            let bytes = core_file_read_until_eof(fd) else trap("read_until_eof")
            assert(ak.byte_buffer_size(&bytes) == 1750)
        .ak_error(_): trap("the file opens")

    let missing = new LoaderTestFileResult(result = ErrorOrI32.value(value = -1)) else trap("out of memory")
    var missing_request = FileRequest(m_path = ak.byte_string_empty())
    file_request_construct(&missing_request, ak.byte_string_from_str("/nonexistent/p2d/missing.html"), ak.Function1[ErrorOrI32, unit](call = LoaderTestFileResult.call, context = missing))
    in_process_request_file(missing_request)
    loader_test_drain(&event_loop)
    match missing.result:
        .value(_): trap("the file is missing")
        .ak_error(failure): assert(ak.ak_error_code(&failure) == 2)