dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / html / tests_html_browsing.lucb
#==============================================================================================
#
# tests_html_browsing - region r28's tests: a top-level traversable for a test page and a
# document initialized for it end to end (its Window, WindowProxy, browsing context and
# realm), base URLs, a connected style sheet through the cascade, and a collection over a
# page with its window and document
#
# DESCRIPTION:
# The scenarios follow what Ladybird does for a page's first navigation: create a new
# top-level traversable (its browsing context and initial about:blank document), then
# Document::create_and_initialize for a response of the navigation, which creates the
# realm whose global object is a new Window and whose global this value is the browsing
# context's WindowProxy.
#
#==============================================================================================
# mark: Helpers =================================================================================
## A response of a navigation to `url`, as Fetch would deliver it: its URL list « url » and a
## `Content-Type: text/html` header.
func test_browsing_response(vm: Vm*, url: str) -> FetchResponse*:
let response = fetch_infrastructure_response_create(vm)
ak.vector_append_t(fetch_response_url_list(response), domurl_parse(ak.sv(url)) else trap("the test URL parses"))
http_header_list_append(fetch_response_header_list(response), http_header_create(ak.sv("Content-Type"), ak.sv("text/html")))
return response
## Navigation params for a response of `navigable`, as Navigable::populate_session_history_entry
## makes them for a fetched response: the response's origin, a new policy container, no sandboxing.
func test_browsing_navigation_params(vm: Vm*, navigable: HtmlNavigable*, response: FetchResponse*) -> HtmlNavigationParams*:
let heap = vm_heap(vm)
let response_url = fetch_response_url(response) else trap("the response has no URL")
let origin = web_url.url_origin(&response_url)
let coop = HtmlOpenerPolicy()
let coop_enforcement_result = HtmlOpenerPolicyEnforcementResult(url = response_url, origin = origin, opener_policy = coop)
let policy_container = heap_allocate_html_policy_container(heap)
return heap_allocate_html_navigation_params(heap, ak.string_from_str("test-navigation"), navigable, none, response, none, none, coop_enforcement_result, none, origin, policy_container, (HtmlSandboxingFlagSet)0, coop, none, HtmlUserNavigationInvolvement.none_)
## A page of `vm` with a new top-level traversable (Page::set_top_level_traversable as the
## embedder's create_a_fresh_top_level_traversable does).
func test_browsing_page_with_traversable(vm: Vm*) -> (Page*, HtmlTraversableNavigable*):
let page = web_test_create_page(vm)
test_fonts_setup()
let traversable = html_traversable_navigable_create_a_new_top_level_traversable(page, none, ak.String())
page_set_top_level_traversable(page, traversable)
return (page, traversable)
# mark: Document::create_and_initialize =========================================================
test "Document::create_and_initialize: a P1 HTML document with its Window, WindowProxy, browsing context and realm":
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()
# The traversable is top-level, on its page, with a browsing context whose initial
# about:blank document is its active document.
assert(html_navigable_is_top_level_traversable(navigable))
assert(html_navigable_page(navigable) == page)
let browsing_context = html_navigable_active_browsing_context(navigable) else trap("no active browsing context")
assert(html_browsing_context_is_top_level(browsing_context))
let initial_document = html_navigable_active_document(navigable) else trap("no active document")
assert(dom_document_is_initial_about_blank(initial_document))
assert(test_html_string_is(dom_document_url_string(initial_document), "about:blank"))
let initial_window = html_navigable_active_window(navigable) else trap("no active window")
assert(html_window_associated_document(initial_window) == initial_document)
assert(page_top_level_traversable(page) == traversable)
# Initialize a document for a navigation response.
let response = test_browsing_response(vm, "https://example.com/dir/page.html")
let params = test_browsing_navigation_params(vm, navigable, response)
let document = dom_document_create_and_initialize(DocumentDomDocumentType.html, ak.string_from_str("text/html"), params) else trap("create_and_initialize threw")
assert(test_html_string_is(dom_document_url_string(document), "https://example.com/dir/page.html"))
assert(test_html_string_is(dom_document_content_type(document), "text/html"))
assert(dom_document_browsing_context(document) == browsing_context)
assert(dom_document_page(document) == page)
assert(document.m_readiness == HtmlDocumentReadyState.loading)
# Its window: a new Window of a new realm, whose associated Document is the document.
let window = dom_document_window(document) else trap("no window")
assert(window != initial_window)
assert(html_window_associated_document(window) == document)
assert(html_relevant_realm((JsObject*)document) == bind_platform_object_realm(window.bind_platform_object()))
let realm = bind_platform_object_realm(window.bind_platform_object())
assert(realm_global_object(realm) == (JsObject*)window)
# The realm's global this value is the browsing context's WindowProxy.
let window_proxy = html_browsing_context_window_proxy(browsing_context) else trap("no WindowProxy")
assert(html_window_window(window) == window_proxy)
assert(html_window_self(window) == window_proxy)
assert(html_window_frames(window) == window_proxy)
# The window's settings object answers from the document.
let settings = html_relevant_settings_object_js_object((JsObject*)window)
assert(html_environment_settings_object_responsible_document(settings) == document)
let api_base_url = html_environment_settings_object_api_base_url(settings)
assert(test_html_string_is(web_url.url_serialize(&api_base_url), "https://example.com/dir/page.html"))
let document_origin = dom_document_origin(document)
assert(web_url.origin_is_same_origin(&document_origin, html_environment_settings_object_origin(settings)))
# The document has a new, global CustomElementRegistry.
assert(html_is_a_global_custom_element_registry(dom_document_custom_element_registry(document)))
assert((HtmlCustomElementRegistry*?)html_window_custom_elements(window) == dom_document_custom_element_registry(document))
# The window's navigable is the traversable once the document is its active document;
# until then it is the initial document's.
assert(html_window_navigable(initial_window) == (HtmlNavigable*?)navigable)
# Navigating to a URL fetches it (Fetch::Fetching, region p2c): the documents of these tests come from
# responses made as above (a srcdoc iframe's, an embedder's) or from about:blank.
## A document initialized for a navigation response to `url` in a new top-level traversable of a
## test page of `vm` (as the first test does), and its traversable.
func test_browsing_initialized_document(vm: Vm*, url: str) -> (DomDocument*, HtmlTraversableNavigable*):
let (page, traversable) = test_browsing_page_with_traversable(vm)
_ = page
let response = test_browsing_response(vm, url)
let params = test_browsing_navigation_params(vm, traversable.html_navigable(), response)
let document = dom_document_create_and_initialize(DocumentDomDocumentType.html, ak.string_from_str("text/html"), params) else trap("create_and_initialize threw")
return (document, traversable)
## Parses `html` into `document`, as the navigation's HTML parser would.
func test_browsing_parse(document: DomDocument*, html: str):
let parser = html_parser_create(document, ak.sv(html), HtmlParserScriptingMode.disabled, ak.sv("UTF-8"))
html_parser_run_url(parser, dom_document_url(document))
## Whether `url` serializes as `text`.
func test_browsing_url_is(url: web_url.Url, text: str) -> bool:
let serialized = web_url.url_serialize(&url)
return test_html_string_is(serialized, text)
# mark: Base URLs ===============================================================================
test "a document's base URL: its URL, then its first base element with an href, against which URLs resolve":
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 (document, traversable) = test_browsing_initialized_document(vm, "https://example.com/dir/page.html")
_ = traversable
# Without a base element, the fallback base URL is the document's URL.
assert(test_browsing_url_is(dom_document_base_url(document), "https://example.com/dir/page.html"))
let relative = dom_document_encoding_parse_url(document, ak.sv("img/a.png")) else trap("the URL parses")
assert(test_browsing_url_is(relative, "https://example.com/dir/img/a.png"))
# The first base element with an href attribute sets the frozen base URL.
test_browsing_parse(document, "<!DOCTYPE html><html><head><base target=_blank><base href='/assets/v2/'><base href='other/'></head><body><a href='x.html'>x</a></body></html>")
assert(test_browsing_url_is(dom_document_base_url(document), "https://example.com/assets/v2/"))
let resolved = dom_document_encoding_parse_url(document, ak.sv("img/a.png")) else trap("the URL parses")
assert(test_browsing_url_is(resolved, "https://example.com/assets/v2/img/a.png"))
let absolute = dom_document_encoding_parse_url(document, ak.sv("//cdn.example.org/s.css")) else trap("the URL parses")
assert(test_browsing_url_is(absolute, "https://cdn.example.org/s.css"))
# The window's settings object answers the same API base URL.
let window = dom_document_window(document) else trap("no window")
let settings = html_relevant_settings_object_js_object((JsObject*)window)
assert(test_browsing_url_is(html_environment_settings_object_api_base_url(settings), "https://example.com/assets/v2/"))
# The about:blank document of the new top-level traversable has about:blank as its base URL.
let initial_document = html_navigable_active_document(traversable.html_navigable()) else trap("no active document")
assert(test_browsing_url_is(dom_document_base_url(initial_document), "about:blank"))
# mark: Style =========================================================================================
test "a connected style element applies its rules to a document of a window through the cascade":
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:
test_page_client_color_scheme = CssPreferredColorScheme.light
defer test_page_client_color_scheme = CssPreferredColorScheme.auto
let (document, traversable) = test_browsing_initialized_document(vm, "https://example.com/style.html")
_ = traversable
test_browsing_parse(document, "<!DOCTYPE html><html><head><style>p { color: rgb(0, 128, 0) } #second { color: rgb(1, 2, 3); background-color: rgb(10, 20, 30) }</style></head><body><p id=first>one</p><p id=second style='color: rgb(200, 0, 0)'>two</p></body></html>")
# The style element's sheet is connected: one sheet in the document's style sheets.
assert(ak.vector_size(&dom_document_style_sheets(document).m_sheets) == 1)
dom_document_update_style(document)
let no_context = CssColorResolutionContext()
let first = dom_parent_node_get_element_by_id(document.dom_parent_node(), ak.fly_string_from_str("first")) else trap("no #first")
let first_color = css_computed_properties_color(dom_element_computed_properties(first) else trap("no computed properties"), css_data.PropertyId.color, no_context)
assert(gfx.color_red(&first_color) == 0 and gfx.color_green(&first_color) == 128 and gfx.color_blue(&first_color) == 0)
# The id rule wins over the type rule, the style attribute over both.
let second = dom_parent_node_get_element_by_id(document.dom_parent_node(), ak.fly_string_from_str("second")) else trap("no #second")
let second_properties = dom_element_computed_properties(second) else trap("no computed properties")
let second_color = css_computed_properties_color(second_properties, css_data.PropertyId.color, no_context)
assert(gfx.color_red(&second_color) == 200 and gfx.color_green(&second_color) == 0 and gfx.color_blue(&second_color) == 0)
let second_background = css_computed_properties_color(second_properties, css_data.PropertyId.background_color, no_context)
assert(gfx.color_red(&second_background) == 10 and gfx.color_green(&second_background) == 20 and gfx.color_blue(&second_background) == 30)
# mark: Collection ==============================================================================
## What make_test_browsing_graph made: the root of the page and weak references to the rest.
struct TestBrowsingGraph:
var page_root: gc.Root[Page]
var document_root: gc.Root[DomDocument]
var page: gc.Weak[Page]
var traversable: gc.Weak[HtmlTraversableNavigable]
var browsing_context: gc.Weak[HtmlBrowsingContext]
var window_proxy: gc.Weak[HtmlWindowProxy]
var initial_document: gc.Weak[DomDocument]
var initial_window: gc.Weak[HtmlWindow]
var document: gc.Weak[DomDocument]
var window: gc.Weak[HtmlWindow]
var element: gc.Weak[DomElement]
## A page with a top-level traversable and a document initialized for it with an element, made with the
## VM's heap as the current allocator; the page and the document are rooted.
noinline func make_test_browsing_graph(vm: Vm*) -> TestBrowsingGraph:
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let (document, traversable) = test_browsing_initialized_document(vm, "https://example.com/gc.html")
# The tree is built by hand: a parser's end would keep the document (through its end
# state's deferred progress check) until the Core event loop runs it.
let element = dom_create_element(document, ak.fly_string_from_str("p"), none) else trap("create_element failed")
_ = dom_node_append_child(document.dom_node(), element.dom_node()) else trap("append_child failed")
let page = html_navigable_page(traversable.html_navigable())
let browsing_context = html_navigable_active_browsing_context(traversable.html_navigable()) else trap("no browsing context")
return TestBrowsingGraph(page_root = gc.root_create(page), document_root = gc.root_create(document), page = gc.make_weak(page), traversable = gc.make_weak(traversable), browsing_context = gc.make_weak(browsing_context), window_proxy = gc.make_weak(html_browsing_context_window_proxy(browsing_context)), initial_document = gc.make_weak(html_navigable_active_document(traversable.html_navigable())), initial_window = gc.make_weak(html_navigable_active_window(traversable.html_navigable())), document = gc.make_weak(document), window = gc.make_weak(dom_document_window(document)), element = gc.make_weak(element))
noinline func run_browsing_collection():
web_initialize_strings()
let vm = web_test_create_vm()
_ = web_test_install_agent(vm)
web_test_install_event_loop_plugin()
defer web_test_remove_event_loop_plugin()
let navigables_before = ak.hash_table_size(html_all_navigables())
let windows_before = ak.hash_table_size(html_all_windows())
var graph = make_test_browsing_graph(vm)
# The new traversable, and the initial and the new window, are registered.
assert(ak.hash_table_size(html_all_navigables()) == navigables_before + 1)
assert(ak.hash_table_size(html_all_windows()) == windows_before + 2)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
# The page keeps its traversable, browsing context, WindowProxy and initial document and window
# (through Page, Navigable, BrowsingContext, DocumentState and Window::visit_edges); the
# document's root keeps it, its window (its realm's global object) and its elements.
assert(web_test_alive(&graph.page))
assert(web_test_alive(&graph.traversable))
assert(web_test_alive(&graph.browsing_context))
assert(web_test_alive(&graph.window_proxy))
assert(web_test_alive(&graph.initial_document))
assert(web_test_alive(&graph.initial_window))
assert(web_test_alive(&graph.document))
assert(web_test_alive(&graph.window))
assert(web_test_alive(&graph.element))
# Without the document's root, the document, its window and its elements go.
gc.root_release(&graph.document_root)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(web_test_alive(&graph.page))
assert(web_test_alive(&graph.initial_window))
assert(not web_test_alive(&graph.document))
assert(not web_test_alive(&graph.window))
assert(not web_test_alive(&graph.element))
assert(ak.hash_table_size(html_all_windows()) == windows_before + 1)
# Without the page's root, everything goes, and the finalizers leave the C-heap registries.
gc.root_release(&graph.page_root)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(not web_test_alive(&graph.page))
assert(not web_test_alive(&graph.traversable))
assert(not web_test_alive(&graph.browsing_context))
assert(not web_test_alive(&graph.window_proxy))
assert(not web_test_alive(&graph.initial_document))
assert(not web_test_alive(&graph.initial_window))
assert(ak.hash_table_size(html_all_navigables()) == navigables_before)
assert(ak.hash_table_size(html_all_windows()) == windows_before)
web_test_destroy_vm(vm)
test "a full collection marks a page's traversable, browsing context, windows and documents, and frees them after":
web_test_clobber_stack()
run_browsing_collection()