Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / event_loop / tests_event_loop.lucb

#==============================================================================================
#
#   tests_event_loop - tests of the HTML event loop, tasks and task queues (region r29)
#
#   DESCRIPTION:
#       Ladybird has no unit tests for HTML/EventLoop (it is exercised by every
#       Tests/LibWeb test), so these pin the C++ behaviour: task ids and runnability, the task
#       queue's order and filters, the processing model (one runnable task per round, then a
#       microtask checkpoint, rescheduled on the Platform::Timer the embedder's loop fires),
#       microtasks queued by microtasks, the steps run on reaching step 1, global tasks,
#       pausing, the documents of the event loop (through collections), the backup incumbent realm stack, updating
#       the rendering with no renderable document, unique task sources, parallel queues and
#       the animation frame callback driver. The event loop runs over r13's scripted
#       TestEventLoop (tests_platform), whose timers the tests fire.
#
#==============================================================================================

# mark: Helpers =================================================================================

## A log of numbered steps.
struct TestHtmlLog:
    var entries: i32[16]
    var count: usize

## The captures of a logged step: the log, the number, and an optional microtask to queue.
struct TestHtmlLogStep:
    var log: TestHtmlLog*
    var number: i32
    var queue_microtask_number: i32
    var vm: Vm*

## A logged step: appends its number; queues a logged microtask when asked to.
func test_html_log_step(context: void*?):
    let step = (TestHtmlLogStep*)(context else trap("no captures"))
    step.log.entries[step.log.count] = step.number
    step.log.count += 1
    if step.queue_microtask_number != 0:
        html_queue_a_microtask(none, test_html_log_steps(step.vm, step.log, step.queue_microtask_number))

## The GC::Function of a logged step.
func test_html_log_steps(vm: Vm*, log: TestHtmlLog*, number: i32, queue_microtask_number: i32 = 0) -> gc.Function0[unit]*:
    let step = new TestHtmlLogStep(log = log, number = number, queue_microtask_number = queue_microtask_number, vm = vm) else trap("out of memory")
    return gc.create_function0(vm_heap(vm), ak.Function0[unit](call = test_html_log_step, context = step))

## Whether the log holds exactly `expected`.
func test_html_log_is(log: const TestHtmlLog*, expected: const i32[]) -> bool:
    if log.count != expected.length:
        return false
    for i in 0..<expected.length:
        if log.entries[i] != expected[i]:
            return false
    return true

## An HTML document in `realm`'s heap, registered with the main thread event loop (its finalize
## unregisters it): page/tests_page's web_test_create_document, which runs Document's constructor,
## so a collection can mark it fully.
func test_html_heap_document(realm: Realm*) -> DomDocument*:
    return web_test_create_document(realm, DocumentDomDocumentType.html)

## The filter that accepts every document.
func test_html_any_document(context: void*?, document: DomDocument*) -> bool:
    return true

## A filter for take_first_runnable_matching / remove_tasks_matching: the task `context`.
func test_html_is_task(context: void*?, task: HtmlTask*) -> bool:
    return (void*?)task == context

# mark: Tasks ===================================================================================

test "Task: increasing ids, its source and document, runnable without a document":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    var log = TestHtmlLog()
    let first = html_task_create(vm, HtmlTaskSource.dom_manipulation, none, test_html_log_steps(vm, &log, 1))
    let second = html_task_create(vm, HtmlTaskSource.networking, none, test_html_log_steps(vm, &log, 2))
    assert(html_task_id(second) == html_task_id(first) + 1)
    assert(html_task_source(first) == HtmlTaskSource.dom_manipulation)
    assert(html_task_document(first) == none)
    assert(html_task_is_runnable(first) and not html_task_is_permanently_unrunnable(first))
    html_task_execute(second)
    html_task_execute(first)
    assert(test_html_log_is(&log, [2, 1]))

    # A document that is not fully active (it has no navigable) makes its task unrunnable; a
    # destroyed one makes it permanently unrunnable.
    let document = test_document_in_realm(realm)
    let task = html_task_create(vm, HtmlTaskSource.dom_manipulation, document, test_html_log_steps(vm, &log, 3))
    assert(html_task_document(task) == document)
    assert(not html_task_is_runnable(task) and not html_task_is_permanently_unrunnable(task))
    document.m_has_been_destroyed = true
    assert(html_task_is_permanently_unrunnable(task))

test "TaskQueue: order, rendering tasks, unrunnable tasks and the filters":
    let test_loop = install_test_event_loop()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    let queue = html_event_loop_task_queue(event_loop)
    var log = TestHtmlLog()
    let document = test_document_in_realm(realm)

    let waiting = html_task_create(vm, HtmlTaskSource.dom_manipulation, document, test_html_log_steps(vm, &log, 1))
    let rendering = html_task_create(vm, HtmlTaskSource.rendering, none, test_html_log_steps(vm, &log, 2))
    let plain = html_task_create(vm, HtmlTaskSource.networking, none, test_html_log_steps(vm, &log, 3))
    html_task_queue_add(queue, waiting)
    # Adding a task schedules the event loop: its single-shot timer is registered.
    assert(test_loop.registrations == 1 and event_loop.m_system_event_loop_timer != none)
    html_task_queue_enqueue(queue, rendering)
    html_task_queue_add(queue, plain)
    assert(test_loop.registrations == 1)
    assert(not html_task_queue_is_empty(queue))
    assert(html_task_queue_last_added_task(queue) == plain)
    assert(html_task_queue_has_rendering_tasks(queue))
    assert(html_task_queue_has_runnable_tasks(queue))

    # While the rendering task runs, rendering tasks are skipped.
    event_loop.m_running_rendering_task = true
    assert(html_task_queue_take_first_runnable(queue) == plain)
    assert(html_task_queue_has_runnable_tasks(queue) == false)
    event_loop.m_running_rendering_task = false
    assert(html_task_queue_has_runnable_tasks(queue))

    # The waiting task's document is not fully active: it stays; once destroyed it is dropped.
    document.m_has_been_destroyed = true
    assert(html_task_queue_take_first_runnable_matching(queue, ak.Function1[HtmlTask*, bool](call = test_html_is_task, context = waiting)) == none)
    assert(ak.vector_size(&queue.m_tasks) == 1)
    assert(html_task_queue_take_first_runnable(queue) == rendering)
    assert(html_task_queue_is_empty(queue))
    assert(html_task_queue_dequeue(queue) == none and html_task_queue_last_added_task(queue) == none)

    # remove_tasks_matching removes without running; dequeue takes the first.
    let a = html_task_create(vm, HtmlTaskSource.timer_task, none, test_html_log_steps(vm, &log, 4))
    let b = html_task_create(vm, HtmlTaskSource.timer_task, none, test_html_log_steps(vm, &log, 5))
    html_task_queue_add(queue, a)
    html_task_queue_add(queue, b)
    html_task_queue_remove_tasks_matching(queue, ak.Function1[HtmlTask*, bool](call = test_html_is_task, context = a))
    assert(html_task_queue_dequeue(queue) == b)
    assert(log.count == 0)

    # Tasks of a temporary document for fragment parsing are not queued.
    let fragment_document = test_document_in_realm(realm)
    fragment_document.m_temporary_document_for_fragment_parsing = DomDocumentTemporaryDocumentForFragmentParsing.yes
    html_task_queue_add(queue, html_task_create(vm, HtmlTaskSource.dom_manipulation, fragment_document, test_html_log_steps(vm, &log, 6)))
    assert(html_task_queue_is_empty(queue))

# mark: The processing model ====================================================================

test "processing: one task per round, then its microtasks; the timer is re-armed while tasks remain":
    let test_loop = install_test_event_loop()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    var log = TestHtmlLog()

    _ = html_queue_a_task(HtmlTaskSource.dom_manipulation, none, none, test_html_log_steps(vm, &log, 1, queue_microtask_number = 10))
    _ = html_queue_a_task(HtmlTaskSource.networking, event_loop, none, test_html_log_steps(vm, &log, 2, queue_microtask_number = 20))
    _ = html_queue_a_task(HtmlTaskSource.dom_manipulation, none, none, test_html_log_steps(vm, &log, 3))
    # A task on the microtask source goes to the microtask queue.
    _ = html_queue_a_task(HtmlTaskSource.microtask, none, none, test_html_log_steps(vm, &log, 4))
    html_run_when_event_loop_reaches_step_1(test_html_log_steps(vm, &log, 5))
    assert(log.count == 0 and test_loop.registrations == 1)
    assert(not html_event_loop_microtask_queue_empty(event_loop))

    fire_test_timer(test_loop, 1)
    assert(test_html_log_is(&log, [5, 1, 4, 10]))
    assert(platform_timer_is_active(event_loop.m_system_event_loop_timer else trap("no timer")))
    assert(html_event_loop_currently_running_task(event_loop) == none)
    fire_test_timer(test_loop, 1)
    assert(test_html_log_is(&log, [5, 1, 4, 10, 2, 20]))
    fire_test_timer(test_loop, 1)
    assert(test_html_log_is(&log, [5, 1, 4, 10, 2, 20, 3]))
    # Nothing is left to run: the timer stays stopped and the idle period start time is set.
    assert(not platform_timer_is_active(event_loop.m_system_event_loop_timer else trap("no timer")))
    assert(event_loop.m_last_idle_period_start_time > 0.0)
    assert(test_loop.timers[0] == none)
    _ = realm

test "microtasks: a checkpoint runs microtasks queued by microtasks, in order, and does not nest":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    var log = TestHtmlLog()
    html_queue_a_microtask(none, test_html_log_steps(vm, &log, 1, queue_microtask_number = 3))
    html_queue_a_microtask(none, test_html_log_steps(vm, &log, 2))
    let task = html_event_loop_dequeue_microtask(event_loop)
    assert(html_task_source(task) == HtmlTaskSource.microtask)
    html_event_loop_enqueue_microtask(event_loop, task)

    # Inside a checkpoint, another checkpoint returns at once.
    event_loop.m_performing_a_microtask_checkpoint = true
    html_perform_a_microtask_checkpoint()
    assert(log.count == 0)
    event_loop.m_performing_a_microtask_checkpoint = false

    html_perform_a_microtask_checkpoint()
    assert(test_html_log_is(&log, [2, 1, 3]))
    assert(html_event_loop_microtask_queue_empty(event_loop))
    assert(not event_loop.m_performing_a_microtask_checkpoint)
    _ = realm

test "queue_global_task: the global's relevant agent's event loop, no document for a non-Window global":
    _ = install_test_event_loop()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let queue = html_event_loop_task_queue(html_main_thread_event_loop())
    var log = TestHtmlLog()
    let id = html_queue_global_task(HtmlTaskSource.user_interaction, realm_global_object(realm), test_html_log_steps(vm, &log, 1))
    let task = html_task_queue_last_added_task(queue) else trap("no task")
    assert(html_task_id(task) == id)
    assert(html_task_source(task) == HtmlTaskSource.user_interaction)
    assert(html_task_document(task) == none)

test "pause: no task runs and checkpoints wait until the pause handle is gone":
    _ = install_test_event_loop()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    let queue = html_event_loop_task_queue(event_loop)
    var log = TestHtmlLog()
    _ = html_queue_a_task(HtmlTaskSource.dom_manipulation, none, none, test_html_log_steps(vm, &log, 1))
    html_queue_a_microtask(none, test_html_log_steps(vm, &log, 2))

    var context: HtmlTemporaryExecutionContext = ---
    html_temporary_execution_context_construct_realm(&context, realm)
    var handle = html_event_loop_pause(event_loop)
    assert(html_event_loop_execution_paused(event_loop))
    assert(handle.event_loop == event_loop and handle.global == realm_global_object(realm))
    assert(not event_loop.m_running_rendering_task)
    assert(not html_task_queue_has_runnable_tasks(queue))
    assert(html_task_queue_take_first_runnable(queue) == none)
    html_temporary_execution_context_destruct(&context)
    assert(log.count == 0)

    html_event_loop_pause_handle_destruct(&handle)
    assert(not html_event_loop_execution_paused(event_loop))
    assert(html_task_queue_has_runnable_tasks(queue))
    html_perform_a_microtask_checkpoint()
    assert(test_html_log_is(&log, [2]))

# mark: Documents, settings objects and the rendering ===========================================

test "the documents of the event loop: registered by the document, unregistered when collected":
    web_test_clobber_stack()
    run_event_loop_documents()

## Two registered documents known only through weak pointers.
noinline func make_test_event_loop_documents(realm: Realm*) -> (gc.Weak[DomDocument], gc.Weak[DomDocument]):
    let first = test_html_heap_document(realm)
    let second = test_html_heap_document(realm)
    second.m_is_decoded_svg = true
    return (gc.make_weak(first), gc.make_weak(second))

noinline func run_event_loop_documents():
    let vm = web_test_create_vm()
    _ = web_test_install_agent(vm)
    let realm = web_test_create_settings_realm(vm)
    let event_loop = html_main_thread_event_loop()
    let (first, second) = make_test_event_loop_documents(realm)
    assert(ak.vector_size(&event_loop.m_documents) == 2)
    assert(event_loop.m_documents_sort_dirty)

    # Decoded SVG documents are never listed; the order is the registration order.
    var documents = html_event_loop_documents_in_this_event_loop_matching(event_loop, ak.Function1[DomDocument*, bool](call = test_html_any_document, context = none))
    assert(ak.vector_size(&documents) == 1)
    assert(*ak.vector_at(&documents, 0) == gc.weak_ptr(&first))
    assert(not event_loop.m_documents_sort_dirty)
    html_event_loop_document_navigable_did_change(event_loop)
    assert(event_loop.m_documents_sort_dirty)
    documents = ak.Vector[DomDocument*?]()

    # No document is fully active (none has a navigable): no same-loop windows, the idle
    # deadline is 50ms after the idle period start.
    var windows = html_event_loop_same_loop_windows(event_loop)
    assert(ak.vector_is_empty(&windows))
    event_loop.m_last_idle_period_start_time = 100.0
    assert(html_event_loop_compute_deadline(event_loop) == 150.0)

    # Updating the rendering finds no renderable document and only toggles its flag.
    html_event_loop_update_the_rendering(event_loop)
    assert(not event_loop.m_running_rendering_task)

    web_test_clobber_stack()
    gc.heap_collect_garbage(vm_heap(vm))
    assert(not web_test_alive(&first) and not web_test_alive(&second))
    assert(ak.vector_is_empty(&event_loop.m_documents))
    web_test_destroy_vm(vm)

test "the documents of the event loop: a live document stays listed through collections":
    web_test_clobber_stack()
    run_event_loop_documents_through_collections()

## A registered document the VM keeps and one nothing keeps, known through weak pointers.
noinline func make_kept_and_dropped_documents(vm: Vm*, realm: Realm*) -> (gc.Weak[DomDocument], gc.Weak[DomDocument]):
    let kept = test_html_heap_document(realm)
    vm_keep_alive(vm, kept)
    return (gc.make_weak(kept), gc.make_weak(test_html_heap_document(realm)))

## Weak pointers to `count` new platform objects nothing keeps: after a collection, the weak
## blocks hand out the WeakImpls it freed first.
noinline func make_dropped_weaks(realm: Realm*, count: usize):
    for _ in 0..<count:
        _ = make_test_agent_root_cell(realm)

## Whether the event loop lists exactly the document of `kept`.
noinline func event_loop_lists_only(event_loop: HtmlEventLoop*, kept: const gc.Weak[DomDocument]*) -> bool:
    if ak.vector_size(&event_loop.m_documents) != 1:
        return false
    if gc.weak_ptr(ak.vector_at(&event_loop.m_documents, 0)) != gc.weak_ptr(kept):
        return false
    var documents = html_event_loop_documents_in_this_event_loop_matching(event_loop, ak.Function1[DomDocument*, bool](call = test_html_any_document, context = none))
    return ak.vector_size(&documents) == 1 and *ak.vector_at(&documents, 0) == gc.weak_ptr(kept)

noinline func run_event_loop_documents_through_collections():
    let vm = web_test_create_vm()
    _ = web_test_install_agent(vm)
    let realm = web_test_create_settings_realm(vm)
    let event_loop = html_main_thread_event_loop()
    # The list's storage comes from the test's allocator, which the collector does not scan,
    # as a list kept on the C heap.
    let (kept, dropped) = make_kept_and_dropped_documents(vm, realm)
    assert(ak.vector_size(&event_loop.m_documents) == 2)
    # A live document is visited in full (it and its page are heap cells).
    for _ in 0..<2:
        test_html_forms_collect(vm)
        make_dropped_weaks(realm, 16)
        assert(web_test_alive(&kept) and not web_test_alive(&dropped))
        assert(event_loop_lists_only(event_loop, &kept))
    web_test_destroy_vm(vm)

test "the backup incumbent realm stack and the termination nesting level":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    let settings = web_test_settings_of(realm)
    let other = web_test_settings_of(web_test_create_settings_realm(vm))
    assert(html_event_loop_is_backup_incumbent_realm_stack_empty(event_loop))
    html_event_loop_push_onto_backup_incumbent_realm_stack(event_loop, settings)
    html_event_loop_push_onto_backup_incumbent_realm_stack(event_loop, other)
    assert(html_event_loop_top_of_backup_incumbent_realm_stack(event_loop) == other)
    html_event_loop_pop_backup_incumbent_realm_stack(event_loop)
    assert(html_event_loop_top_of_backup_incumbent_realm_stack(event_loop) == settings)
    html_event_loop_pop_backup_incumbent_realm_stack(event_loop)
    assert(html_event_loop_is_backup_incumbent_realm_stack_empty(event_loop))

    # Both settings objects registered with their responsible event loop, in creation order.
    assert(ak.vector_size(&event_loop.m_related_environment_settings_objects) == 2)
    assert(gc.weak_ptr(ak.vector_at(&event_loop.m_related_environment_settings_objects, 1)) == other)

    html_event_loop_increment_termination_nesting_level(event_loop)
    html_event_loop_increment_termination_nesting_level(event_loop)
    html_event_loop_decrement_termination_nesting_level(event_loop)
    assert(html_event_loop_termination_nesting_level(event_loop) == 1)

# mark: Task sources and parallel queues ========================================================

test "unique task sources start after the generic sources and are given back":
    var first = HtmlUniqueTaskSource(source = HtmlTaskSource.unspecified)
    var second = HtmlUniqueTaskSource(source = HtmlTaskSource.unspecified)
    html_unique_task_source_construct(&first)
    html_unique_task_source_construct(&second)
    assert((i32)first.source >= (i32)HtmlTaskSource.unique_task_source_start)
    assert((i32)second.source >= (i32)HtmlTaskSource.unique_task_source_start)
    assert(first.source != second.source)
    html_unique_task_source_destruct(&first)
    html_unique_task_source_destruct(&second)

test "ParallelQueue::enqueue queues a task on its unique source on the main thread event loop":
    _ = install_test_event_loop()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    var log = TestHtmlLog()
    let parallel_queue = html_parallel_queue_create()
    let id = html_parallel_queue_enqueue(parallel_queue, test_html_log_steps(vm, &log, 1))
    let task = html_task_queue_last_added_task(html_event_loop_task_queue(html_main_thread_event_loop())) else trap("no task")
    assert(html_task_id(task) == id)
    assert(html_task_source(task) == parallel_queue.m_task_source.source)
    assert(html_task_document(task) == none)
    html_unique_task_source_destruct(&parallel_queue.m_task_source)
    _ = realm

# mark: AnimationFrameCallbackDriver ============================================================

## The captures of a logged animation frame callback.
struct TestHtmlFrameCallback:
    var log: TestHtmlLog*
    var number: i32
    var driver: HtmlAnimationFrameCallbackDriver*
    var vm: Vm*

## A logged animation frame callback; callback 2 adds callback 9 while the driver runs.
func test_html_frame_callback(context: void*?, now: f64):
    let captures = (TestHtmlFrameCallback*)(context else trap("no captures"))
    assert(now == 16.5)
    captures.log.entries[captures.log.count] = captures.number
    captures.log.count += 1
    if captures.number == 2:
        _ = html_animation_frame_callback_driver_add(captures.driver, test_html_frame_function(captures.vm, captures.log, 9, captures.driver))

## The GC::Function of a logged animation frame callback.
func test_html_frame_function(vm: Vm*, log: TestHtmlLog*, number: i32, driver: HtmlAnimationFrameCallbackDriver*) -> gc.Function1[f64, unit]*:
    let captures = new TestHtmlFrameCallback(log = log, number = number, driver = driver, vm = vm) else trap("out of memory")
    return gc.create_function1(vm_heap(vm), ak.Function1[f64, unit](call = test_html_frame_callback, context = captures))

test "AnimationFrameCallbackDriver: ids from 1, removal, and callbacks added while running wait":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let heap = vm_heap(vm)
    let driver = (HtmlAnimationFrameCallbackDriver*)web_heap_allocate_cell(heap, &html_animation_frame_callback_driver_class)
    var log = TestHtmlLog()
    assert(not html_animation_frame_callback_driver_has_callbacks(driver))
    assert(html_animation_frame_callback_driver_add(driver, test_html_frame_function(vm, &log, 1, driver)) == 1)
    assert(html_animation_frame_callback_driver_add(driver, test_html_frame_function(vm, &log, 2, driver)) == 2)
    assert(html_animation_frame_callback_driver_add(driver, test_html_frame_function(vm, &log, 3, driver)) == 3)
    assert(html_animation_frame_callback_driver_remove(driver, 1))
    assert(not html_animation_frame_callback_driver_remove(driver, 1))
    assert(html_animation_frame_callback_driver_has_callbacks(driver))

    html_animation_frame_callback_driver_run(driver, 16.5)
    assert(test_html_log_is(&log, [2, 3]))
    assert(ak.ordered_hash_map_is_empty(&driver.m_executing_callbacks))
    assert(html_animation_frame_callback_driver_has_callbacks(driver))
    assert(ak.ordered_hash_map_contains_k(&driver.m_callbacks, 4))
    html_animation_frame_callback_driver_run(driver, 16.5)
    assert(test_html_log_is(&log, [2, 3, 9]))
    assert(not html_animation_frame_callback_driver_has_callbacks(driver))