dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / webview / tests_webview_tabs.lucb
#==============================================================================================
#
# tests_webview_tabs - views as a tabbed browser's tabs: hidden ones paused, closed ones gone
#
# DESCRIPTION:
# A hidden view (webview_set_system_visibility_state, as the UI hides a tab it switched
# from) gets no rendering task when the event loop updates the rendering, its document
# reports visibilityState "hidden", its loads go on, and shown again it paints at once.
# A destroyed view (a closed tab) leaves nothing of its page on the event loop: no task,
# timer, deferred invocation or socket, not even with a load waiting on a server that
# never answers, and the other views keep rendering.
#
# Copyright (c) 2026 the luce-browser authors.
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Helpers =================================================================================
## The rendering tasks queued for `view`'s page.
func test_webview_rendering_tasks_of(view: WebView*) -> i32:
let page = webview_page(view)
let task_queue = web.html_event_loop_task_queue(web.html_main_thread_event_loop())
var count: i32 = 0
for task in ak.vector_span(&task_queue.m_tasks):
if web.html_task_source(task) != web.HtmlTaskSource.rendering:
continue
let document = web.html_task_document(task) else continue
if web.dom_document_page(document) == page:
count += 1
return count
## The tasks queued for documents of `page` (which may be gone: only compared).
func test_webview_tasks_of_page(page: const void*) -> i32:
let task_queue = web.html_event_loop_task_queue(web.html_main_thread_event_loop())
var count: i32 = 0
for task in ak.vector_span(&task_queue.m_tasks):
let document = web.html_task_document(task) else continue
if (const void*)web.dom_document_page(document) == page:
count += 1
return count
## The view's active document.
func test_webview_document(view: WebView*) -> web.DomDocument*:
let traversable = web.page_top_level_traversable(webview_page(view))
return web.html_navigable_active_document((web.HtmlNavigable*)traversable) else trap("webview tests: no document")
## Pumps until the view's document's visibility state is `state` (the update is a queued task).
func test_webview_wait_for_visibility(view: WebView*, log: TestWebViewLog*, state: web.HtmlVisibilityState):
let start = time.now()
while web.dom_document_visibility_state_value(test_webview_document(view)) != state:
test_webview_turn()
test_webview_take_events(view, log)
if time.now() - start > test_webview_timeout:
trap("webview tests: the document's visibility state did not change")
## Pumps until the view reports that the load of tests/webview/PAGE finished, without waiting for
## a frame (a hidden view presents none).
func test_webview_wait_for_load_only(view: WebView*, log: TestWebViewLog*, page: str):
let start = time.now()
log.awaited_page = page
log.awaited_page_loaded = false
while not log.awaited_page_loaded:
test_webview_turn()
test_webview_take_events(view, log)
if time.now() - start > test_webview_timeout:
trap(f"webview tests: {page} did not finish loading")
log.awaited_page = ""
## The registered timers of the process's event loop.
func test_webview_timers() -> ak.Vector[web.CoreTimer*]:
let event_loop = webview_event_loop()
var timers: ak.Vector[web.CoreTimer*]
for index in 0..<ak.vector_size(&event_loop.timers):
ak.vector_append_t(&timers, ak.vector_at_const(&event_loop.timers, index).timer)
return timers
## Whether `timer` is among `timers`.
func test_webview_has_timer(timers: const ak.Vector[web.CoreTimer*]*, timer: web.CoreTimer*) -> bool:
for index in 0..<ak.vector_size(timers):
if *ak.vector_at_const(timers, index) == timer:
return true
return false
# mark: A server that never answers =============================================================
## How many connections the silent server holds at most.
let test_silent_server_capacity: usize = 8
## A server on 127.0.0.1 that accepts connections, reads them and never answers, each on a
## thread of its own until its client closes it: it counts the connections it accepted and
## those their clients closed. In the C heap.
struct TestSilentServer:
var listener: net.Listener
var port: u16
var stopping: @u64
var accepted: @u64
var closed: @u64
var accept_thread: thread.Handle
var connections: net.Connection[8]
var readers: thread.Handle[8]
## A connection's reader: reads until the client closes it.
struct TestSilentReader:
var server: TestSilentServer*
var index: usize
func test_silent_server_read(context: void*?):
let reader = (TestSilentReader*)(context else trap("no reader"))
let server = reader.server
var buffer: u8[1024] = ---
while true:
let count = server.connections[reader.index].read(buffer[0..]) catch: break
if count == 0:
break
_ = server.closed.add(1, .acq_rel)
free(reader) in memory.heap
func test_silent_server_accept(context: void*?):
let server = (TestSilentServer*)(context else trap("no server"))
while server.stopping.load(.acquire) == 0:
var connection = server.listener.accept() catch: return
if server.stopping.load(.acquire) != 0:
connection.destroy()
return
let index = (usize)server.accepted.load(.acquire)
if index >= test_silent_server_capacity:
connection.destroy()
continue
server.connections[index] = connection
with memory.heap:
let reader = new TestSilentReader(server = server, index = index) else trap("out of memory")
server.readers[index] = thread.spawn(test_silent_server_read, reader, name = "silent-reader") else trap("the reader's thread")
_ = server.accepted.add(1, .acq_rel)
func test_silent_server_start() -> TestSilentServer*:
with memory.heap:
let listener = net.Listener.bind(net.SocketAddress.loopback(0)) else trap("the server's listener")
let port = listener.port() else trap("the server's port")
let server = new TestSilentServer(listener = listener, port = port) else trap("out of memory")
server.accept_thread = thread.spawn(test_silent_server_accept, server, name = "silent-server") else trap("the server's thread")
return server
## Stops accepting and joins every thread (the readers end as their clients closed).
func test_silent_server_stop(server: TestSilentServer*):
server.stopping.store(1, .release)
with memory.heap:
var wake = net.Connection.connect(net.SocketAddress.loopback(server.port)) catch: recover net.Connection()
wake.destroy()
var joined = server.accept_thread
joined.join() else trap("the server's thread joins")
# A connection the client keeps (an idle one in its pool, the process's as RequestServer's
# are) ends here.
for index in 0..<(usize)server.accepted.load(.acquire):
server.connections[index].shutdown() catch failure:
_ = failure
for index in 0..<(usize)server.accepted.load(.acquire):
var reader = server.readers[index]
reader.join() else trap("a reader's thread joins")
server.connections[index].destroy()
server.listener.destroy()
free(server) in memory.heap
## Appends `port` in decimal.
func test_silent_server_append_port(builder: ak.StringBuilder*, port: u16):
var digits: u8[5] = ---
var count: usize = 0
var rest = port
while true:
digits[4 - count] = (u8)(rest % 10) + 48
count += 1
rest = rest // 10
if rest == 0:
break
ak.string_builder_append(builder, (str)digits[5 - count..])
## The server's URL for `path`.
func test_silent_server_url(server: const TestSilentServer*, path: str) -> web_url.Url:
var builder = ak.string_builder_new()
ak.string_builder_append(&builder, "http://127.0.0.1:")
test_silent_server_append_port(&builder, server.port)
ak.string_builder_append(&builder, path)
return web_url.parser_basic_parse(ak.string_builder_string_view(&builder)) else trap("webview tests: not a URL")
## Pumps until the server accepted `count` connections.
func test_silent_server_wait_for(server: TestSilentServer*, count: u64):
let start = time.now()
while server.accepted.load(.acquire) < count:
test_webview_turn()
if time.now() - start > test_webview_timeout:
trap("webview tests: the request did not reach the server")
# mark: Hidden views ============================================================================
test "hidden views get no rendering task and report a hidden document; the visible one renders":
test_webview_platform()
let allocator: memory.Allocator = webview_heap()
with allocator:
let shown = test_webview_open()
defer webview_destroy(shown)
let first_hidden = test_webview_open()
defer webview_destroy(first_hidden)
let second_hidden = test_webview_open()
defer webview_destroy(second_hidden)
var shown_log = TestWebViewLog()
var hidden_log = TestWebViewLog()
webview_load(shown, test_webview_file_url("first.html"))
webview_load(first_hidden, test_webview_file_url("first.html"))
webview_load(second_hidden, test_webview_file_url("second.html"))
test_webview_wait_for_load(shown, &shown_log, "first.html")
test_webview_wait_for_load(first_hidden, &hidden_log, "first.html")
hidden_log = TestWebViewLog()
test_webview_wait_for_load(second_hidden, &hidden_log, "second.html")
webview_set_system_visibility_state(first_hidden, web.HtmlVisibilityState.hidden)
webview_set_system_visibility_state(second_hidden, web.HtmlVisibilityState.hidden)
test_webview_wait_for_visibility(first_hidden, &hidden_log, web.HtmlVisibilityState.hidden)
test_webview_wait_for_visibility(second_hidden, &hidden_log, web.HtmlVisibilityState.hidden)
assert(web.dom_document_hidden(test_webview_document(first_hidden)), "the hidden view's document is hidden")
let hidden_state = web.dom_document_visibility_state(test_webview_document(second_hidden))
let visible_state = web.dom_document_visibility_state(test_webview_document(shown))
assert(ak.string_view_eq_string_view(&hidden_state, ak.sv("hidden")), "visibilityState is \"hidden\"")
assert(ak.string_view_eq_string_view(&visible_state, ak.sv("visible")), "the shown view's is \"visible\"")
# Once the queue holds no rendering task, the event loop's next update of the rendering
# queues one for the shown view only.
let start = time.now()
let task_queue = web.html_event_loop_task_queue(web.html_main_thread_event_loop())
while web.html_task_queue_has_rendering_tasks(task_queue):
test_webview_turn()
if time.now() - start > test_webview_timeout:
trap("webview tests: a rendering task stays queued")
web.html_event_loop_queue_task_to_update_the_rendering(web.html_main_thread_event_loop())
assert(test_webview_rendering_tasks_of(shown) == 1, "the shown view gets a rendering task")
assert(test_webview_rendering_tasks_of(first_hidden) == 0, "a hidden view gets none")
assert(test_webview_rendering_tasks_of(second_hidden) == 0, "a hidden view gets none")
test_webview_sync_rendering(shown, &shown_log)
test "a hidden view keeps loading, presents nothing, and paints at once when shown":
test_webview_platform()
let allocator: memory.Allocator = webview_heap()
with allocator:
let shown = test_webview_open()
defer webview_destroy(shown)
let view = test_webview_open()
defer webview_destroy(view)
var log = TestWebViewLog()
webview_load(view, test_webview_file_url("first.html"))
test_webview_wait_for_load(view, &log, "first.html")
assert(test_webview_pixel(view, 5, 5) == 0x0000ffff, "the first page is presented")
webview_set_system_visibility_state(view, web.HtmlVisibilityState.hidden)
test_webview_wait_for_visibility(view, &log, web.HtmlVisibilityState.hidden)
let frames = log.frames
webview_load(view, test_webview_file_url("second.html"))
test_webview_wait_for_load_only(view, &log, "second.html")
test_webview_settle(view, &log, 100)
assert(web.dom_document_hidden(test_webview_document(view)), "the document loaded in the background is hidden")
assert(log.frames == frames, "a hidden view presents no frame")
assert(test_webview_pixel(view, 5, 5) == 0x0000ffff, "the hidden view still shows the first page")
webview_set_system_visibility_state(view, web.HtmlVisibilityState.visible)
test_webview_wait_for_frame(view, &log)
assert(not web.dom_document_hidden(test_webview_document(view)), "the shown view's document is visible")
assert(test_webview_pixel(view, 5, 5) == 0x008000ff, "the page loaded in the background is painted")
# mark: Destroyed views =========================================================================
test "a destroyed view leaves no task, timer or socket of its page, and the others keep rendering":
test_webview_platform()
let allocator: memory.Allocator = webview_heap()
with allocator:
let server = test_silent_server_start()
defer test_silent_server_stop(server)
let other = test_webview_open()
defer webview_destroy(other)
var other_log = TestWebViewLog()
webview_load(other, test_webview_file_url("first.html"))
test_webview_wait_for_load(other, &other_log, "first.html")
test_webview_wait_for_idle(other, &other_log)
let timers_before = test_webview_timers()
# A busy page: a running animation (a frame each turn) and a refresh timer; then a
# navigation to the server, which never answers.
let busy = test_webview_open()
var busy_log = TestWebViewLog()
webview_load(busy, test_webview_file_url("busy.html"))
test_webview_wait_for_load(busy, &busy_log, "busy.html")
let busy_document = test_webview_document(busy)
assert(busy_document.m_active_refresh_timer != none, "the refresh timer is set")
webview_load(busy, test_silent_server_url(server, "/never"))
test_silent_server_wait_for(server, 1)
# A page whose image never arrives: its load waits on it.
let slow = test_webview_open()
var page_html = ak.string_builder_new()
ak.string_builder_append(&page_html, "<!DOCTYPE html><title>Slow</title><img src=\"http://127.0.0.1:")
test_silent_server_append_port(&page_html, server.port)
ak.string_builder_append(&page_html, "/image\">")
webview_load_html(slow, ak.string_builder_string_view(&page_html))
test_silent_server_wait_for(server, 2)
assert(web.dom_document_readiness(test_webview_document(slow)) != web.HtmlDocumentReadyState.complete, "the slow page waits for its image")
# A task queued for each, then both destroyed.
webview_set_system_visibility_state(busy, web.HtmlVisibilityState.hidden)
webview_set_system_visibility_state(slow, web.HtmlVisibilityState.hidden)
let busy_page = (const void*)webview_page(busy)
let slow_page = (const void*)webview_page(slow)
assert(test_webview_tasks_of_page(busy_page) > 0, "a task is queued for the busy page")
webview_destroy(busy)
webview_destroy(slow)
assert(test_webview_tasks_of_page(busy_page) == 0 and test_webview_tasks_of_page(slow_page) == 0,
"no task of a destroyed page is left")
# The server sees both connections closed; the loop runs out of work.
let start = time.now()
while server.closed.load(.acquire) < 2:
test_webview_turn()
if time.now() - start > test_webview_timeout:
trap(f"webview tests: a destroyed view request stayed open ({server.accepted.load(.acquire)} accepted, {server.closed.load(.acquire)} closed)")
test_webview_wait_for_idle(other, &other_log)
test_webview_settle(other, &other_log, 50)
let event_loop = webview_event_loop()
assert(ak.vector_is_empty(&event_loop.deferred), "no deferred invocation is left")
assert(web.core_event_loop_notifiers_count(&event_loop.notifiers) == 0, "no socket is watched")
var timers_after = test_webview_timers()
for index in 0..<ak.vector_size(&timers_after):
assert(test_webview_has_timer(&timers_before, *ak.vector_at(&timers_after, index)), "no timer of a destroyed page is left")
# The collector takes the pages (finalizing what they held); the other view renders on.
gc.heap_collect_garbage(web.vm_heap(webview_platform().vm))
webview_load(other, test_webview_file_url("second.html"))
test_webview_wait_for_load(other, &other_log, "second.html")
assert(test_webview_pixel(other, 5, 5) == 0x008000ff, "the other view renders its new page")