dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / web_idl / tests_promise.lucb
#==============================================================================================
#
# tests_promise - tests of the phase-1 promises, sets and maps (DESIGN.md §3.6)
#
# DESCRIPTION:
# The JS::Promise, PromiseCapability, JS::Set and JS::Map stand-ins and the WebIDL promise
# operations over them, in a principal realm of tests_environments whose VM has the main
# thread VM's promise host hooks (web_test_install_agent). They pin the order the
# ECMAScript spec and LibJS give: reactions run as microtasks in the order they were
# triggered, a derived promise settles one tick later, resolving with a promise takes two
# more ticks; the rejection tracker's lists; wait for all; insertion order and SameValue
# of sets and maps; and what a collection keeps.
#
#==============================================================================================
# mark: Helpers =================================================================================
## A logged reaction step: appends its number to the log, remembers the value it was given and
## answers `result` (or the value when there is none).
struct TestPromiseStep:
var log: TestHtmlLog*
var number: i32
var seen: JsValue
var result: JsValue?
## The behaviour of a logged reaction step.
func test_promise_step_call(context: void*?, value: JsValue) -> JsValue:
let step = (TestPromiseStep*)(context else trap("no captures"))
step.log.entries[step.log.count] = step.number
step.log.count += 1
step.seen = value
return step.result else value
## A logged reaction step `number` (ReactionSteps, a GC::Function) and its record.
func test_promise_step(vm: Vm*, log: TestHtmlLog*, number: i32, result: JsValue? = none) -> (gc.Function1[JsValue, JsValue]*, TestPromiseStep*):
let step = new TestPromiseStep(log = log, number = number, seen = js_undefined(), result = result) else trap("out of memory")
return (gc.create_function1(vm_heap(vm), ak.Function1[JsValue, JsValue](call = test_promise_step_call, context = step)), step)
## The JS::Promise of a WebIDL promise.
func test_promise_object(promise: JsPromiseCapability*) -> JsPromise*:
return as_js_promise((gc.Cell*)js_promise_capability_promise(promise))
## Whether a value is the number `expected`.
func test_promise_is_number(value: JsValue, expected: f64) -> bool:
return js_value_is_number(value) and js_value_as_double(value) == expected
## The UniversalGlobalScopeMixin of a test realm's global.
func test_promise_global_mixin(realm: Realm*) -> HtmlUniversalGlobalScopeMixin*:
return html_environment_settings_object_universal_global_scope(html_principal_realm_settings_object(realm))
## How many promises wait in the global's about-to-be-notified rejected promises list.
func test_promise_about_to_be_notified(realm: Realm*) -> usize:
let list = test_promise_global_mixin(realm).m_about_to_be_notified_rejected_promises_list else return 0
return ak.vector_size(list)
## Enter `realm` as a TemporaryExecutionContext with callbacks enabled does (prepare to run
## script and a callback, so that HostMakeJobCallback finds an incumbent settings object).
func test_promise_enter(realm: Realm*) -> HtmlEnvironmentSettingsObject*:
let settings = html_principal_realm_settings_object(realm)
html_prepare_to_run_script(settings)
html_prepare_to_run_callback(settings)
return settings
## Leave what test_promise_enter entered, as the TemporaryExecutionContext's destructor does:
## cleaning up after running script performs a microtask checkpoint once the execution context
## stack is empty.
func test_promise_leave(settings: HtmlEnvironmentSettingsObject*):
html_clean_up_after_running_script(settings)
html_clean_up_after_running_callback(settings)
# mark: Settling and reacting ===================================================================
test "WebIDL promises: reactions run as microtasks in order, once, with the value":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
var log = TestHtmlLog()
let settings = test_promise_enter(realm)
let promise = idl_create_promise(realm)
assert(js_promise_state(test_promise_object(promise)) == JsPromiseState.pending)
assert(js_object_shape_realm(js_promise_capability_promise(promise)) == realm)
let (first, first_step) = test_promise_step(vm, &log, 1)
let (second, second_step) = test_promise_step(vm, &log, 2)
let (on_rejection, rejection_step) = test_promise_step(vm, &log, 9)
_ = idl_upon_fulfillment(promise, first)
_ = idl_upon_fulfillment(promise, second)
_ = idl_upon_rejection(promise, on_rejection)
# A microtask queued before the resolution runs first; the reactions are jobs queued by
# the resolution, in the order they were registered; a microtask queued after runs last.
html_queue_a_microtask(none, test_html_log_steps(vm, &log, 10))
idl_resolve_promise(realm, promise, js_value_from_f64(42.0))
html_queue_a_microtask(none, test_html_log_steps(vm, &log, 20))
assert(log.count == 0)
assert(idl_is_promise_fulfilled(promise))
# Resolving or rejecting again does nothing.
idl_resolve_promise(realm, promise, js_value_from_f64(7.0))
idl_reject_promise(realm, promise, js_value_from_f64(8.0))
assert(test_promise_is_number(js_promise_result(test_promise_object(promise)), 42.0))
test_promise_leave(settings)
assert(test_html_log_is(&log, [10, 1, 2, 20]))
assert(test_promise_is_number(first_step.seen, 42.0) and test_promise_is_number(second_step.seen, 42.0))
# Reacting to a settled promise queues the job at once; it runs at the next checkpoint.
_ = test_promise_enter(realm)
let (late, late_step) = test_promise_step(vm, &log, 3)
_ = idl_upon_fulfillment(promise, late)
assert(log.count == 4)
test_promise_leave(settings)
assert(test_html_log_is(&log, [10, 1, 2, 20, 3]))
assert(test_promise_is_number(late_step.seen, 42.0))
assert(js_value_is_undefined(rejection_step.seen))
assert(vm_execution_context_stack(vm).length == 0)
test "WebIDL promises: derived promises settle a tick later, chains interleave":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
var log = TestHtmlLog()
let settings = test_promise_enter(realm)
# a.then(A1).then(A2) and b.then(B1).then(B2): A1 B1 A2 B2.
let a = idl_create_promise(realm)
let b = idl_create_promise(realm)
let (a1, a1_step) = test_promise_step(vm, &log, 1, js_value_from_f64(100.0))
let (a2, a2_step) = test_promise_step(vm, &log, 2)
let (b1, b1_step) = test_promise_step(vm, &log, 3)
let (b2, b2_step) = test_promise_step(vm, &log, 4)
let derived_a = idl_upon_fulfillment(a, a1)
_ = idl_upon_fulfillment(derived_a, a2)
_ = idl_upon_fulfillment(idl_upon_fulfillment(b, b1), b2)
idl_resolve_promise(realm, a, js_value_from_f64(1.0))
idl_resolve_promise(realm, b, js_value_from_f64(2.0))
test_promise_leave(settings)
assert(test_html_log_is(&log, [1, 3, 2, 4]))
assert(test_promise_is_number(a1_step.seen, 1.0) and test_promise_is_number(b1_step.seen, 2.0) and test_promise_is_number(b2_step.seen, 2.0))
# The derived promise is resolved with A1's result.
assert(test_promise_is_number(a2_step.seen, 100.0))
assert(test_promise_is_number(js_promise_result(test_promise_object(derived_a)), 100.0))
test "resolving with a promise takes two more ticks (NewPromiseResolveThenableJob, then the reaction)":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
var log = TestHtmlLog()
let settings = test_promise_enter(realm)
# c.then(C1).then(C2).then(C3), and p resolved with an already fulfilled q.
let c = idl_create_promise(realm)
let (c1, c1_step) = test_promise_step(vm, &log, 1)
let (c2, c2_step) = test_promise_step(vm, &log, 2)
let (c3, c3_step) = test_promise_step(vm, &log, 3)
_ = idl_upon_fulfillment(idl_upon_fulfillment(idl_upon_fulfillment(c, c1), c2), c3)
let q = idl_create_resolved_promise(realm, js_value_from_f64(5.0))
let p = idl_create_promise(realm)
let (p1, p1_step) = test_promise_step(vm, &log, 4)
_ = idl_upon_fulfillment(p, p1)
idl_resolve_promise(realm, c, js_undefined())
idl_resolve_promise(realm, p, js_value_from_object(js_promise_capability_promise(q)))
# p is not fulfilled yet: its resolution waits for q.then().
assert(js_promise_state(test_promise_object(p)) == JsPromiseState.pending)
test_promise_leave(settings)
assert(test_html_log_is(&log, [1, 2, 3, 4]))
assert(test_promise_is_number(p1_step.seen, 5.0))
assert(js_value_is_undefined(c1_step.seen) and js_value_is_undefined(c2_step.seen) and js_value_is_undefined(c3_step.seen))
assert(idl_is_promise_fulfilled(p))
test "rejection: upon_rejection gets the reason; a fulfillment reaction's derived promise is rejected":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
var log = TestHtmlLog()
let settings = test_promise_enter(realm)
let promise = idl_create_promise(realm)
let (on_fulfilled, fulfilled_step) = test_promise_step(vm, &log, 1)
let (on_rejected, rejected_step) = test_promise_step(vm, &log, 2)
let derived = idl_upon_fulfillment(promise, on_fulfilled)
let (derived_rejected, derived_step) = test_promise_step(vm, &log, 3)
idl_mark_promise_as_handled(idl_upon_rejection(derived, derived_rejected))
_ = idl_upon_rejection(promise, on_rejected)
idl_reject_promise(realm, promise, js_value_from_f64(13.0))
assert(js_promise_state(test_promise_object(promise)) == JsPromiseState.rejected)
assert(not idl_is_promise_fulfilled(promise))
test_promise_leave(settings)
# The fulfillment step never runs; the derived promise is rejected with the same reason.
assert(test_html_log_is(&log, [2, 3]))
assert(js_value_is_undefined(fulfilled_step.seen))
assert(test_promise_is_number(rejected_step.seen, 13.0))
assert(test_promise_is_number(derived_step.seen, 13.0))
assert(js_promise_state(test_promise_object(derived)) == JsPromiseState.rejected)
# A rejected promise made by create_rejected_promise.
_ = test_promise_enter(realm)
let rejected = idl_create_rejected_promise(realm, js_value_from_f64(21.0))
assert(js_promise_state(test_promise_object(rejected)) == JsPromiseState.rejected)
assert(test_promise_is_number(js_promise_result(test_promise_object(rejected)), 21.0))
idl_mark_promise_as_handled(rejected)
test_promise_leave(settings)
test "HostPromiseRejectionTracker: unhandled rejections wait for notification, handling removes them":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
var log = TestHtmlLog()
let settings = test_promise_enter(realm)
# Rejected without a handler: "reject" puts it on the about-to-be-notified list.
let unhandled = idl_create_promise(realm)
idl_reject_promise(realm, unhandled, js_value_from_f64(1.0))
assert(test_promise_about_to_be_notified(realm) == 1)
# A handler added before the checkpoint: "handle" takes it off again.
let (on_rejected, rejected_step) = test_promise_step(vm, &log, 1)
_ = idl_upon_rejection(unhandled, on_rejected)
assert(test_promise_about_to_be_notified(realm) == 0)
assert(js_promise_is_handled(test_promise_object(unhandled)))
# Marked as handled before it is rejected: nothing is tracked.
let handled = idl_create_promise(realm)
idl_mark_promise_as_handled(handled)
idl_reject_promise(realm, handled, js_value_from_f64(2.0))
assert(test_promise_about_to_be_notified(realm) == 0)
# A promise handled only after its rejection was tracked stays on the list until the
# checkpoint notifies about it: the list is cleared and a global task queued (it skips
# promises handled by then; html/tests_promise_rejection_event runs it).
let late = idl_create_rejected_promise(realm, js_value_from_f64(3.0))
assert(test_promise_about_to_be_notified(realm) == 1)
idl_mark_promise_as_handled(late)
let task_queue = html_event_loop_task_queue(html_main_thread_event_loop())
assert(html_task_queue_is_empty(task_queue))
test_promise_leave(settings)
assert(test_html_log_is(&log, [1]))
assert(test_promise_is_number(rejected_step.seen, 1.0))
assert(test_promise_global_mixin(realm).m_about_to_be_notified_rejected_promises_list == none)
assert(not html_task_queue_is_empty(task_queue))
test "LibJS's default hooks: without LibWeb's, promise jobs wait in the VM's queue until run":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let context = js_execution_context_create()
context.realm = realm
vm_push_execution_context(vm, context)
var log = TestHtmlLog()
let promise = idl_create_promise(realm)
let (step, step_record) = test_promise_step(vm, &log, 1)
_ = idl_upon_fulfillment(promise, step)
idl_resolve_promise(realm, promise, js_value_from_bool(true))
assert(log.count == 0)
assert(not vm_host_promise_job_queue_is_empty(vm))
vm_run_queued_promise_jobs(vm)
assert(test_html_log_is(&log, [1]))
assert(js_value_as_bool(step_record.seen))
assert(vm_host_promise_job_queue_is_empty(vm))
_ = vm_pop_execution_context(vm)
# mark: Wait for all ============================================================================
## What the wait-for-all steps saw.
struct TestWaitForAll:
var successes: i32
var failures: i32
var results: ak.Vector[JsValue]
var reason: JsValue
## wait_for_all's success steps of a test.
func test_wait_for_all_success(context: void*?, results: const ak.Vector[JsValue]*):
let record = (TestWaitForAll*)(context else trap("no record"))
record.successes += 1
record.results = ak.vector_clone(results)
## wait_for_all's failure steps of a test.
func test_wait_for_all_failure(context: void*?, reason: JsValue):
let record = (TestWaitForAll*)(context else trap("no record"))
record.failures += 1
record.reason = reason
## Wait for all of `promises` into `record`.
func test_wait_for_all(realm: Realm*, promises: const JsPromiseCapability*[], record: TestWaitForAll*):
idl_wait_for_all(realm, promises, ak.Function1[const ak.Vector[JsValue]*, unit](call = test_wait_for_all_success, context = record), ak.Function1[JsValue, unit](call = test_wait_for_all_failure, context = record))
test "wait for all: results in the promises' order, the first rejection once, none in a microtask":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let settings = test_promise_enter(realm)
let first = idl_create_promise(realm)
let second = idl_create_promise(realm)
let third = idl_create_resolved_promise(realm, js_value_from_f64(3.0))
var all: const JsPromiseCapability*[3] = [first, second, third]
let record = new TestWaitForAll(successes = 0, failures = 0, results = ak.Vector[JsValue](), reason = js_undefined()) else trap("out of memory")
test_wait_for_all(realm, all[0..<3], record)
idl_resolve_promise(realm, second, js_value_from_f64(2.0))
idl_resolve_promise(realm, first, js_value_from_f64(1.0))
test_promise_leave(settings)
assert(record.successes == 1 and record.failures == 0)
assert(ak.vector_size(&record.results) == 3)
for i: usize in 0..<3:
assert(test_promise_is_number(*ak.vector_at(&record.results, i), (f64)(i + 1)))
# Two rejections: the failure steps run once, with the first reason.
_ = test_promise_enter(realm)
let a = idl_create_promise(realm)
let b = idl_create_promise(realm)
var both: const JsPromiseCapability*[2] = [a, b]
let failing = new TestWaitForAll(successes = 0, failures = 0, results = ak.Vector[JsValue](), reason = js_undefined()) else trap("out of memory")
test_wait_for_all(realm, both[0..<2], failing)
idl_reject_promise(realm, b, js_value_from_f64(7.0))
idl_reject_promise(realm, a, js_value_from_f64(8.0))
test_promise_leave(settings)
assert(failing.successes == 0 and failing.failures == 1)
assert(test_promise_is_number(failing.reason, 7.0))
# No promises: the success steps run with « » in a microtask.
_ = test_promise_enter(realm)
var none_: const JsPromiseCapability*[1] = [first]
let empty = new TestWaitForAll(successes = 0, failures = 0, results = ak.Vector[JsValue](), reason = js_undefined()) else trap("out of memory")
test_wait_for_all(realm, none_[0..<0], empty)
assert(empty.successes == 0)
test_promise_leave(settings)
assert(empty.successes == 1 and ak.vector_size(&empty.results) == 0)
# mark: Sets and maps ===========================================================================
test "JS::Set: insertion order, add/has/remove/size, SameValue keys":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let set = js_set_create(realm)
assert(js_set_set_size(set) == 0)
assert(js_object_shape_realm((JsObject*)set) == realm)
let object = realm_create_bind_platform_object_realm(realm, realm, JsObjectMayInterfereWithIndexedPropertyAccess.no)
let object_value = js_value_from_object((JsObject*)object)
js_set_set_add(set, js_value_from_f64(3.0))
js_set_set_add(set, object_value)
js_set_set_add(set, js_value_from_f64(1.0))
js_set_set_add(set, js_value_from_f64(3.0))
js_set_set_add(set, js_value_from_f64(math.nan))
js_set_set_add(set, js_value_from_f64(0.0 - math.nan))
assert(js_set_set_size(set) == 4)
assert(js_set_set_has(set, object_value))
assert(js_set_set_has(set, js_value_from_f64(math.nan)))
assert(not js_set_set_has(set, js_value_from_f64(2.0)))
# SameValue tells +0 from -0 (Set.prototype.add canonicalizes -0 before it gets here).
js_set_set_add(set, js_value_from_f64(0.0))
assert(not js_set_set_has(set, js_value_from_f64(-0.0)))
# Values in insertion order; re-adding does not move a value; removing keeps the others' order.
var values = js_set_values(set)
assert(ak.vector_size(&values) == 5)
assert(test_promise_is_number(*ak.vector_at(&values, 0), 3.0))
assert(js_value_as_object(*ak.vector_at(&values, 1)) == (JsObject*)object)
assert(test_promise_is_number(*ak.vector_at(&values, 2), 1.0))
assert(js_set_set_remove(set, js_value_from_f64(3.0)))
assert(not js_set_set_remove(set, js_value_from_f64(3.0)))
js_set_set_add(set, js_value_from_f64(3.0))
values = js_set_values(set)
assert(ak.vector_size(&values) == 5)
assert(js_value_as_object(*ak.vector_at(&values, 0)) == (JsObject*)object)
assert(test_promise_is_number(*ak.vector_at(&values, 4), 3.0))
js_set_set_clear(set)
let cleared = js_set_values(set)
assert(js_set_set_size(set) == 0 and ak.vector_is_empty(&cleared))
test "JS::Map: map_set replaces in place, entries in insertion order":
let (vm, realm) = web_test_create_vm_and_settings_realm()
defer web_test_destroy_vm(vm)
let map = js_map_create(realm)
js_map_map_set(map, js_value_from_f64(2.0), js_value_from_bool(true))
js_map_map_set(map, js_null(), js_value_from_f64(5.0))
js_map_map_set(map, js_value_from_f64(2.0), js_value_from_bool(false))
assert(js_map_map_size(map) == 2)
var entries = js_map_entries(map)
assert(test_promise_is_number(ak.vector_at(&entries, 0).key, 2.0))
assert(not js_value_as_bool(ak.vector_at(&entries, 0).value))
assert(js_value_is_null(ak.vector_at(&entries, 1).key))
assert(test_promise_is_number(js_map_map_get(map, js_null()) else js_undefined(), 5.0))
if let missing = js_map_map_get(map, js_undefined()):
trap(f"undefined is not a key: {js_value_is_undefined(missing)}")
# mark: Collections =============================================================================
test "a pending promise's reactions and a set's values live as long as the promise and the set":
web_test_clobber_stack()
run_pending_promise_collection()
## The cells of a pending promise with a reaction whose step holds a set, kept by the root the
## caller gets.
noinline func make_test_pending_promise(vm: Vm*, realm: Realm*, log: TestHtmlLog*) -> (gc.Root[JsPromise], gc.Weak[JsSet], gc.Weak[BindPlatformObject]):
# Managed memory is the current allocator, as when the embedder runs the event loop `with heap`.
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let settings = test_promise_enter(realm)
let set = js_set_create(realm)
let object = realm_create_bind_platform_object_realm(realm, realm, JsObjectMayInterfereWithIndexedPropertyAccess.no)
js_set_set_add(set, js_value_from_object((JsObject*)object))
let promise = idl_create_promise(realm)
let (step, step_record) = test_promise_step(vm, log, 1, js_value_from_object((JsObject*)set))
_ = step_record
_ = idl_upon_fulfillment(promise, step)
test_promise_leave(settings)
return (gc.root_create(test_promise_object(promise)), gc.make_weak(set), gc.make_weak(object))
noinline func run_pending_promise_collection():
let (vm, realm) = web_test_create_vm_and_settings_realm()
var log = TestHtmlLog()
var (root, weak_set, weak_object) = make_test_pending_promise(vm, realm, &log)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
# The promise's reaction keeps its handler, whose step's captures keep the set and its value.
assert(web_test_alive(&weak_set))
assert(web_test_alive(&weak_object))
gc.root_release(&root)
web_test_clobber_stack()
gc.heap_collect_garbage(vm_heap(vm))
assert(not web_test_alive(&weak_set))
assert(not web_test_alive(&weak_object))
assert(log.count == 0)
web_test_destroy_vm(vm)