dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / html / tests_html_loading.lucb
#==============================================================================================
#
# tests_html_loading - NavigationObserver and preloaded resources (region p2d)
#
# DESCRIPTION:
# Ladybird has no unit tests for NavigationObserver or PreloadEntry. These pin, from the
# C++: an observer registered with its navigable on creation, its callbacks set and
# cleared, and unregistered when it is collected; a preload entry's members and what it
# keeps alive; consuming a preloaded resource whose response is or is not there yet, and
# one that is not in the document's map (the keys' URL, destination, mode and credentials
# mode all count). The preload keys' hash is pinned by tests_loader_1's oracle cases.
#
#==============================================================================================
# mark: NavigationObserver ======================================================================
## A Function0 that counts its calls.
func test_html_loading_count(context: void*?):
let count = (i32*)(context else trap("no counter"))
*count += 1
## Makes an observer of `navigable` from a frame of its own, with both callbacks; answers a Weak to it.
noinline func test_html_loading_make_observer(realm: Realm*, navigable: HtmlNavigable*, count: i32*) -> gc.Weak[HtmlNavigationObserver]:
let observer = realm_create_html_navigation_observer(realm, realm, navigable)
html_navigation_observer_set_navigation_complete(observer, ak.Function0[unit](call = test_html_loading_count, context = count))
html_navigation_observer_set_ongoing_navigation_changed(observer, ak.Function0[unit](call = test_html_loading_count, context = count))
return gc.make_weak[HtmlNavigationObserver](observer)
test "NavigationObserver: registered with its navigable, its callbacks set and cleared, unregistered when collected":
web_initialize_strings()
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
_ = web_test_install_agent(vm)
web_test_install_event_loop_plugin()
defer web_test_remove_event_loop_plugin()
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let (page, traversable) = test_browsing_page_with_traversable(vm)
let navigable = traversable.html_navigable()
let document = html_navigable_active_document(navigable) else trap("an active document")
let realm = dom_document_realm(document)
assert(ak.intrusive_list_is_empty(&navigable.m_navigation_observers))
let count = new i32 else trap("out of memory")
let observer = realm_create_html_navigation_observer(realm, realm, navigable)
assert(is_html_navigation_observer(observer) and observer.m_navigable == navigable)
assert(ak.intrusive_list_size_slow(&navigable.m_navigation_observers) == 1)
assert(html_navigation_observer_navigation_complete(observer) == none and html_navigation_observer_ongoing_navigation_changed(observer) == none)
html_navigation_observer_set_navigation_complete(observer, ak.Function0[unit](call = test_html_loading_count, context = count))
let complete = html_navigation_observer_navigation_complete(observer) else trap("a navigation_complete callback")
ak.function0_call(&complete.function)
assert(*count == 1)
html_navigation_observer_set_ongoing_navigation_changed(observer, ak.Function0[unit](call = test_html_loading_count, context = count))
assert(html_navigation_observer_ongoing_navigation_changed(observer) != none)
# An empty function, or none, clears a callback.
html_navigation_observer_set_navigation_complete(observer, ak.Function0[unit]())
assert(html_navigation_observer_navigation_complete(observer) == none)
html_navigation_observer_set_ongoing_navigation_changed(observer, none)
assert(html_navigation_observer_ongoing_navigation_changed(observer) == none)
# An observer nothing holds is collected, and its finalize unregisters it.
let weak = test_html_loading_make_observer(realm, navigable, count)
assert(ak.intrusive_list_size_slow(&navigable.m_navigation_observers) == 2)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(not web_test_alive(&weak))
assert(ak.intrusive_list_size_slow(&navigable.m_navigation_observers) == 1)
assert(page_top_level_traversable(page) == traversable)
# mark: Preloaded resources =====================================================================
## A Function1 that records the response it is called with.
func test_html_loading_response(context: void*?, response: FetchResponse*):
let seen = (FetchResponse*?*)(context else trap("no slot"))
*seen = response
## The key of a preload of `url`: an image, no-cors, include.
func test_html_loading_key(url: str) -> HtmlPreloadKey:
return HtmlPreloadKey(url = web_url.parser_basic_parse(ak.sv(url)) else trap("the URL parses"), destination = FetchRequestDestination.image,
mode = FetchRequestMode.no_cors, credentials_mode = FetchRequestCredentialsMode.include)
test "PreloadEntry: preload keys of requests, entries, and consuming a preloaded resource":
web_initialize_strings()
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
_ = web_test_install_agent(vm)
web_test_install_event_loop_plugin()
defer web_test_remove_event_loop_plugin()
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let (page, traversable) = test_browsing_page_with_traversable(vm)
let navigable = traversable.html_navigable()
let window = html_navigable_active_window(navigable) else trap("an active window")
let document = html_window_associated_document(window)
let realm = dom_document_realm(document)
assert(page_top_level_traversable(page) == traversable)
# A request's preload key: its URL, destination, mode and credentials mode.
let request = html_create_potential_cors_request(vm, web_url.parser_basic_parse(ak.sv("https://example.com/a.png")) else trap("a URL"), FetchRequestDestination.image,
HtmlCorsSettingAttribute.no_cors)
let key = html_create_a_preload_key(request)
let expected = test_html_loading_key("https://example.com/a.png")
assert(html_preload_key_eq(&key, &expected))
let other_mode = HtmlPreloadKey(url = expected.url, destination = expected.destination, mode = FetchRequestMode.cors, credentials_mode = expected.credentials_mode)
assert(not html_preload_key_eq(&key, &other_mode))
let no_destination = HtmlPreloadKey(url = expected.url, destination = none, mode = expected.mode, credentials_mode = expected.credentials_mode)
assert(not html_preload_key_eq(&key, &no_destination))
# An entry: no response, no callback; its integrity metadata.
let entry = realm_create_html_preload_entry(realm)
assert(is_html_preload_entry(entry))
assert(html_preload_entry_response(entry) == none and html_preload_entry_on_response_available(entry) == none)
assert(ak.string_is_empty(&entry.integrity_metadata))
html_preload_entry_set_integrity_metadata(entry, ak.string_from_str("sha256-abc"))
assert(ak.string_eq_string_view(&entry.integrity_metadata, ak.sv("sha256-abc")))
# Consuming it before its response: the callback becomes the entry's, and the key leaves the map.
let preloads = dom_document_map_of_preloaded_resources(document)
_ = ak.hash_map_set(preloads, key, entry)
let seen = new FetchResponse*? else trap("out of memory")
let on_response_available = gc.create_function1(vm_heap(vm), ak.Function1[FetchResponse*, unit](call = test_html_loading_response, context = seen))
assert(not html_consume_a_preloaded_resource(window, other_mode.url, FetchRequestDestination.image, FetchRequestMode.cors, FetchRequestCredentialsMode.include,
ak.String(), on_response_available))
assert(html_consume_a_preloaded_resource(window, key.url, FetchRequestDestination.image, FetchRequestMode.no_cors, FetchRequestCredentialsMode.include,
ak.string_from_str("sha256-other"), on_response_available))
assert(ak.hash_map_size(preloads) == 0)
assert(html_preload_entry_on_response_available(entry) == on_response_available and *seen == none)
assert(not html_consume_a_preloaded_resource(window, key.url, FetchRequestDestination.image, FetchRequestMode.no_cors, FetchRequestCredentialsMode.include,
ak.String(), on_response_available))
# Consuming one whose response is there: the callback hears it at once.
let second = realm_create_html_preload_entry(realm)
let response = fetch_infrastructure_response_create(vm)
html_preload_entry_set_response(second, response)
_ = ak.hash_map_set(preloads, key, second)
assert(html_consume_a_preloaded_resource(window, key.url, FetchRequestDestination.image, FetchRequestMode.no_cors, FetchRequestCredentialsMode.include,
ak.String(), on_response_available))
assert(*seen == response and html_preload_entry_on_response_available(second) == none)
## An entry with a response and a callback, made from a frame of its own: Weaks to the three.
noinline func test_html_loading_make_entry(vm: Vm*, realm: Realm*, root: gc.Root[HtmlPreloadEntry]*) -> (gc.Weak[FetchResponse], gc.Weak[gc.Function1[FetchResponse*, unit]]):
let entry = realm_create_html_preload_entry(realm)
let response = fetch_infrastructure_response_create(vm)
html_preload_entry_set_response(entry, response)
let callback = gc.create_function1(vm_heap(vm), ak.Function1[FetchResponse*, unit](call = test_html_loading_response, context = none))
entry.on_response_available = callback
*root = gc.root_create(entry)
return (gc.make_weak[FetchResponse](response), gc.make_weak[gc.Function1[FetchResponse*, unit]](callback))
test "PreloadEntry: visit_edges keeps its response and its callback":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
var root: gc.Root[HtmlPreloadEntry] = ---
let (response, callback) = test_html_loading_make_entry(vm, realm, &root)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(web_test_alive(&response) and web_test_alive(&callback))
gc.root_release(&root)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(not web_test_alive(&response) and not web_test_alive(&callback))