dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / tests_media_invalidation_3.lucb
#==============================================================================================
#
# tests_media_invalidation_3 - focused tests of region r42: three-valued logic, boolean
# expressions, MediaFeature::compare, MediaQueryList,
# VisualViewport, the Preferred* strings, InvalidationSet and
# InvalidationPlan, and the style invalidator
#
# DESCRIPTION:
# What the oracle cases (tests_media_invalidation) do not reach: values made directly,
# the classes' ids and vtables, the donor quirks (Formatter<InvalidationSet> writes no
# separator; env() is serialized as font-format()), equality of plans ignoring rule order,
# and the merging that must not share a set's table between rules. The expected values
# follow the C++ (each is a direct reading of the donor's code or of the oracle's output).
#
#==============================================================================================
# mark: Helpers =================================================================================
## Whether a String holds `text`.
func test_r42_is(value: ak.String, text: str) -> bool:
return ak.string_eq_string_view(&value, ak.sv(text))
## Whether a StringView holds `text`.
func test_r42_view_is(value: ak.StringView, text: str) -> bool:
return ak.string_view_equals(&value, text)
## A constant expression of `value`, as a BooleanExpression.
func test_r42_constant(value: CssMatchResult) -> CssBooleanExpression*:
return css_constant_boolean_expression_create(value).css_boolean_expression()
## A vector of two expressions.
func test_r42_pair(a: CssBooleanExpression*, b: CssBooleanExpression*) -> ak.Vector[CssBooleanExpression*]:
var children: ak.Vector[CssBooleanExpression*]
ak.vector_append_t(&children, a)
ak.vector_append_t(&children, b)
return children
## The dump of an expression.
func test_r42_dump(expression: CssBooleanExpression*) -> ak.String:
var builder = ak.string_builder_new()
css_boolean_expression_dump(expression, &builder, 0)
return ak.string_builder_to_string_without_validation(&builder)
## The formatted (AK::Formatter) text of a set.
func test_r42_format(set: const CssInvalidationSet*) -> ak.String:
var builder = ak.string_builder_new()
css_invalidation_set_format(&builder, set)
return ak.string_builder_to_string_without_validation(&builder)
# mark: MatchResult and boolean expressions =====================================================
test "MatchResult: Kleene and/or, negate, as_match_result, to_string":
let f = CssMatchResult.false_
let t = CssMatchResult.true_
let u = CssMatchResult.unknown
assert(css_and(t, t) == t and css_and(t, f) == f and css_and(f, u) == f and css_and(t, u) == u and css_and(u, u) == u)
assert(css_or(f, f) == f and css_or(t, f) == t and css_or(u, t) == t and css_or(f, u) == u and css_or(u, u) == u)
assert(css_negate(t) == f and css_negate(f) == t and css_negate(u) == u)
assert(css_as_match_result(true) == t and css_as_match_result(false) == f)
assert(test_r42_view_is(css_to_string_css_match_result(u), "unknown") and test_r42_view_is(css_to_string_css_match_result(t), "true"))
test "boolean expressions: and/or with unknowns, not, parentheses, serialization and dump":
let t = test_r42_constant(CssMatchResult.true_)
let f = test_r42_constant(CssMatchResult.false_)
let u = css_general_enclosed_create(ak.string_from_str("foo(bar)")).css_boolean_expression()
let and_unknown = css_boolean_and_expression_create(test_r42_pair(t, u)).css_boolean_expression()
assert(css_boolean_expression_evaluate(and_unknown, none) == CssMatchResult.unknown)
assert(not css_boolean_expression_evaluate_to_boolean(and_unknown, none))
assert(css_boolean_expression_evaluate(css_boolean_and_expression_create(test_r42_pair(u, f)).css_boolean_expression(), none) == CssMatchResult.false_)
assert(css_boolean_expression_evaluate(css_boolean_or_expression_create(test_r42_pair(f, u)).css_boolean_expression(), none) == CssMatchResult.unknown)
assert(css_boolean_expression_evaluate(css_boolean_or_expression_create(test_r42_pair(u, t)).css_boolean_expression(), none) == CssMatchResult.true_)
let not_unknown = css_boolean_not_expression_create(u).css_boolean_expression()
assert(css_boolean_expression_evaluate(not_unknown, none) == CssMatchResult.unknown)
let in_parens = css_boolean_expression_in_parens_create(f).css_boolean_expression()
assert(css_boolean_expression_evaluate(css_boolean_not_expression_create(in_parens).css_boolean_expression(), none) == CssMatchResult.true_)
assert(test_r42_is(css_boolean_expression_to_string(and_unknown), "true and foo(bar)"))
assert(test_r42_is(css_boolean_expression_to_string(css_boolean_not_expression_create(in_parens).css_boolean_expression()), "not (false)"))
let matched = css_general_enclosed_create(ak.string_from_str("x"), CssMatchResult.true_)
assert(css_boolean_expression_evaluate(matched.css_boolean_expression(), none) == CssMatchResult.true_)
assert(test_r42_is(test_r42_dump(and_unknown), "AND:\n CONSTANT: true\n GeneralEnclosed: foo(bar)\n"))
assert(test_r42_is(test_r42_dump(css_boolean_not_expression_create(in_parens).css_boolean_expression()), "NOT:\n (\n CONSTANT: false\n )\n"))
test "boolean expressions: class ids and vtables of every class, Supports' tests included":
let enclosed = css_general_enclosed_create(ak.string_from_str("x")).css_boolean_expression()
assert(is_css_general_enclosed(enclosed) and is_css_boolean_expression(enclosed) and not is_css_media_feature(enclosed))
let feature = css_media_feature_boolean(css_data.MediaFeatureId.color).css_boolean_expression()
assert(is_css_media_feature(feature) and feature.class_id == css_media_feature_class.first_id)
let declaration = css_supports_declaration_create(ak.string_from_str("a: b"), true).css_boolean_expression()
let selector = css_supports_selector_create(ak.string_from_str("a > b"), false).css_boolean_expression()
let tech = css_supports_font_tech_create(ak.fly_string_from_str("color-COLRv1"), true).css_boolean_expression()
let format_ = css_supports_font_format_create(ak.fly_string_from_str("woff2"), true).css_boolean_expression()
let env = css_supports_env_create(ak.fly_string_from_str("safe-area-inset-top"), true).css_boolean_expression()
assert(is_css_supports_declaration(declaration) and is_css_supports_selector(selector) and is_css_supports_font_tech(tech))
assert(is_css_supports_font_format(format_) and is_css_supports_env(env) and not is_css_supports_env(format_))
assert(is_css_boolean_expression(env) and env.class_id <= css_boolean_expression_class.last_id)
assert(css_boolean_expression_evaluate(selector, none) == CssMatchResult.false_)
assert(test_r42_is(css_boolean_expression_to_string(selector), "selector(a > b)"))
assert(test_r42_is(css_boolean_expression_to_string(tech), "font-tech(color-COLRv1)"))
# Donor quirk: env() serializes as font-format() (and the parser makes a FontFormat for env()).
assert(test_r42_is(css_boolean_expression_to_string(env), "font-format(safe-area-inset-top)"))
assert(test_r42_is(test_r42_dump(env), "Env: `safe-area-inset-top` matches=true\n"))
assert(test_r42_is(test_r42_dump(declaration), "Declaration: `a: b`, matches=true\n"))
let supports = css_supports_create(css_boolean_and_expression_create(test_r42_pair(declaration, selector)).css_boolean_expression())
assert(not css_supports_matches(supports))
assert(test_r42_is(css_supports_to_string(supports), "a: b and selector(a > b)"))
let container = css_container_query_create(css_boolean_not_expression_create(selector).css_boolean_expression())
assert(css_container_query_matches(container))
assert(test_r42_is(css_container_query_to_string(container), "not selector(a > b)"))
# mark: Media queries ===========================================================================
test "MediaFeature::compare: unknown values, mismatched types and identifiers decide before any length context":
let (vm, realm, document) = test_html_setup()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let dark = css_media_feature_value_create(CssMediaFeatureValueType.ident, css_keyword_style_value_create(css_data.Keyword.dark).css_style_value())
let light = css_media_feature_value_create(CssMediaFeatureValueType.ident, css_keyword_style_value_create(css_data.Keyword.light).css_style_value())
let unknown = css_media_feature_value_create(CssMediaFeatureValueType.unknown, css_keyword_style_value_create(css_data.Keyword.dark).css_style_value())
let number = css_media_feature_value_create(CssMediaFeatureValueType.integer, css_integer_style_value_create(3).css_style_value())
assert(css_media_feature_compare(document, dark, CssMediaFeatureComparison.equal, dark) == CssMatchResult.true_)
assert(css_media_feature_compare(document, dark, CssMediaFeatureComparison.equal, light) == CssMatchResult.false_)
assert(css_media_feature_compare(document, dark, CssMediaFeatureComparison.less_than, dark) == CssMatchResult.false_)
assert(css_media_feature_compare(document, unknown, CssMediaFeatureComparison.equal, dark) == CssMatchResult.unknown)
assert(css_media_feature_compare(document, number, CssMediaFeatureComparison.equal, dark) == CssMatchResult.false_)
assert(css_media_feature_value_ident(&dark) == css_data.Keyword.dark)
# A document without a Window answers false for every feature; the type and `not` still decide.
let feature = css_media_feature_plain(css_data.MediaFeatureId.prefers_color_scheme, dark)
assert(css_boolean_expression_evaluate(feature.css_boolean_expression(), document) == CssMatchResult.false_)
assert(test_r42_is(css_boolean_expression_to_string(feature.css_boolean_expression()), "(prefers-color-scheme: dark)"))
let range = css_media_feature_half_range_media_feature_id(css_data.MediaFeatureId.color, CssMediaFeatureComparison.greater_than_or_equal, number)
assert(test_r42_is(css_boolean_expression_to_string(range.css_boolean_expression()), "(color >= 3)"))
let query = css_media_query_create_not_all()
assert(not css_media_query_evaluate(query, document) and not css_media_query_matches(query))
assert(test_r42_is(css_media_query_to_string(query), "not all"))
assert(css_media_type_from_string(ak.sv("PRINT")) == CssMediaQueryKnownMediaType.print_)
assert(css_media_type_from_string(ak.sv("tv")) == none)
assert(test_r42_is(css_serialize_a_media_query_list(ak.Vector[CssMediaQuery*]()), ""))
test "MediaQueryList: media text, matches and evaluate in a document without a frame":
let (vm, realm, document) = test_html_setup()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
var params: CssParsingParams = ---
css_parsing_params_construct_realm_css_parsing_mode(¶ms, realm)
let screen = css_media_query_list_create(document, parse_media_query_list(params, ak.sv("print, screen")))
assert(test_r42_is(css_media_query_list_media(screen), "print, screen"))
assert(css_media_query_list_evaluate(screen) and css_media_query_list_matches(screen))
assert(css_media_query_list_has_changed_state(screen) == false)
let print_ = css_media_query_list_create(document, parse_media_query_list(params, ak.sv("print")))
assert(not css_media_query_list_matches(print_))
css_media_query_list_set_has_changed_state(print_, true)
assert(css_media_query_list_has_changed_state(print_) == true)
# An empty list matches.
let empty = css_media_query_list_create(document, ak.Vector[CssMediaQuery*]())
assert(css_media_query_list_matches(empty) and css_media_query_list_evaluate(empty))
assert(screen.cell().class_id == css_media_query_list_class.first_id)
test "Preferred color scheme, contrast and motion: from and to strings":
assert(css_preferred_color_scheme_from_string(ak.sv("DARK")) == CssPreferredColorScheme.dark)
assert(css_preferred_color_scheme_from_string(ak.sv("blue")) == CssPreferredColorScheme.auto)
assert(test_r42_view_is(css_preferred_color_scheme_to_string(CssPreferredColorScheme.light), "light"))
assert(css_preferred_contrast_from_string(ak.sv("no-preference")) == CssPreferredContrast.no_preference)
assert(css_preferred_contrast_from_string(ak.sv("More")) == CssPreferredContrast.more)
assert(test_r42_view_is(css_preferred_contrast_to_string(CssPreferredContrast.less), "less"))
assert(css_preferred_motion_from_string(ak.sv("reduce")) == CssPreferredMotion.reduce)
assert(css_preferred_motion_from_string(ak.sv("")) == CssPreferredMotion.auto)
assert(test_r42_view_is(css_preferred_motion_to_string(CssPreferredMotion.no_preference), "no-preference"))
# mark: VisualViewport ==========================================================================
test "VisualViewport: scroll_by, the transform and its inverse, reset; zero offsets when not fully active":
let (vm, realm, document) = test_html_setup()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let viewport = css_visual_viewport_create(document)
assert(css_visual_viewport_scale(viewport) == 1.0)
var delta: gfx.CssPixelPoint = ---
gfx.css_pixel_point_construct_int(&delta, 10, 20)
css_visual_viewport_scroll_by(viewport, delta)
css_visual_viewport_scroll_by(viewport, delta)
let offset = css_visual_viewport_offset(viewport)
assert(offset.m_x.m_value == 20 * 64 and offset.m_y.m_value == 40 * 64)
# The document has no navigable: it is not fully active.
assert(css_visual_viewport_offset_left(viewport) == 0.0 and css_visual_viewport_page_top(viewport) == 0.0 and css_visual_viewport_width(viewport) == 0.0)
# transform(): translate(-offset * scale), then scale(scale).
let transform = css_visual_viewport_transform(viewport)
assert(transform.m_values[0] == 1.0 and transform.m_values[3] == 1.0 and transform.m_values[4] == -20.0 and transform.m_values[5] == -40.0)
var position: gfx.CssPixelPoint = ---
gfx.css_pixel_point_construct_int(&position, 5, 7)
let mapped = css_visual_viewport_map_to_layout_viewport(viewport, position)
assert(mapped.m_x.m_value == 25 * 64 and mapped.m_y.m_value == 47 * 64)
viewport.m_scale = 2.0
let scaled = css_visual_viewport_transform(viewport)
assert(scaled.m_values[0] == 2.0 and scaled.m_values[4] == -40.0 and scaled.m_values[5] == -80.0)
let mapped_scaled = css_visual_viewport_map_to_layout_viewport(viewport, position)
# (5 + 40) / 2 = 22.5 and (7 + 80) / 2 = 43.5, mapped as an IntPoint: AffineTransform::map's round_to<int>
# rounds half to even (cvtss2si, frintn), 22 and 44.
assert(mapped_scaled.m_x.m_value == 22 * 64 and mapped_scaled.m_y.m_value == 44 * 64)
css_visual_viewport_reset(viewport)
assert(css_visual_viewport_scale(viewport) == 1.0 and gfx.css_pixel_point_is_zero(&viewport.m_offset))
assert(dom_document_needs_accumulated_visual_contexts_update(document))
# mark: InvalidationSet and InvalidationPlan ====================================================
test "InvalidationSet: properties, equality, merging, for_each_property order and the Formatter's missing separator":
var a: CssInvalidationSet
assert(css_invalidation_set_is_empty(&a) and not css_invalidation_set_has_properties(&a))
css_invalidation_set_set_needs_invalidate_class(&a, ak.fly_string_from_str("x"))
css_invalidation_set_set_needs_invalidate_class(&a, ak.fly_string_from_str("x"))
css_invalidation_set_set_needs_invalidate_id(&a, ak.fly_string_from_str("x"))
assert(ak.hash_table_size(&a.m_properties) == 2 and css_invalidation_set_has_properties(&a))
var b: CssInvalidationSet
css_invalidation_set_set_needs_invalidate_id(&b, ak.fly_string_from_str("x"))
assert(not css_invalidation_set_eq(&a, b))
css_invalidation_set_set_needs_invalidate_class(&b, ak.fly_string_from_str("x"))
assert(css_invalidation_set_eq(&a, b))
css_invalidation_set_set_needs_invalidate_self(&b)
assert(not css_invalidation_set_eq(&a, b) and css_invalidation_set_needs_invalidate_self(&b))
# A clone owns its table: changing it leaves the original as it was.
var clone = css_invalidation_set_clone(&a)
css_invalidation_set_set_needs_invalidate_pseudo_class(&clone, css_data.PseudoClass.hover)
assert(ak.hash_table_size(&a.m_properties) == 2 and ak.hash_table_size(&clone.m_properties) == 3)
var c: CssInvalidationSet
css_invalidation_set_set_needs_invalidate_whole_subtree(&c)
css_invalidation_set_set_needs_invalidate_attribute(&c, ak.fly_string_from_str("href"))
css_invalidation_set_include_all_from(&c, b)
assert(css_invalidation_set_needs_invalidate_self(&c) and css_invalidation_set_needs_invalidate_whole_subtree(&c))
assert(ak.hash_table_size(&c.m_properties) == 3)
# for_each_property: `$` and `*` first, then the table.
var properties: ak.Vector[CssInvalidationSetProperty]
for property in css_invalidation_set_properties(&c):
ak.vector_append_t(&properties, property)
assert(ak.vector_size(&properties) == 5)
assert(ak.vector_span(&properties)[0].type_ == CssInvalidationSetPropertyType.invalidate_self)
assert(ak.vector_span(&properties)[1].type_ == CssInvalidationSetPropertyType.invalidate_whole_subtree)
# Donor quirk: Formatter<InvalidationSet> never clears `first`, so the properties run together.
var single: CssInvalidationSet
css_invalidation_set_set_needs_invalidate_self(&single)
css_invalidation_set_set_needs_invalidate_tag_name(&single, ak.fly_string_from_str("div"))
assert(test_r42_is(test_r42_format(&single), "$div"))
let pseudo = CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(css_data.PseudoClass.focus_within))
var builder = ak.string_builder_new()
css_invalidation_set_property_format(&builder, &pseudo)
assert(test_r42_view_is(ak.string_builder_string_view(&builder), ":focus-within"))
let other_pseudo = CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(css_data.PseudoClass.focus))
assert(not css_invalidation_set_property_eq(&pseudo, &other_pseudo) and css_invalidation_set_property_eq(&pseudo, &pseudo))
test "InvalidationPlan: equality ignores rule order, include_all_from merges equal payloads and stops at whole subtree":
let leaf = css_invalidation_plan_create()
leaf.invalidate_self = true
var set_a: CssInvalidationSet
css_invalidation_set_set_needs_invalidate_class(&set_a, ak.fly_string_from_str("a"))
var set_b: CssInvalidationSet
css_invalidation_set_set_needs_invalidate_class(&set_b, ak.fly_string_from_str("b"))
let first = css_invalidation_plan_create()
ak.vector_append_t(&first.sibling_rules, CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.adjacent, match_set = set_a, payload = leaf))
ak.vector_append_t(&first.sibling_rules, CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.subsequent, match_set = set_b, payload = leaf))
let second = css_invalidation_plan_create()
ak.vector_append_t(&second.sibling_rules, CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.subsequent, match_set = set_b, payload = leaf))
ak.vector_append_t(&second.sibling_rules, CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.adjacent, match_set = set_a, payload = leaf))
assert(css_invalidation_plan_eq(first, *second))
second.invalidate_self = true
assert(not css_invalidation_plan_eq(first, *second))
assert(not css_invalidation_plan_is_empty(first))
# Two descendant rules with equal payloads merge their match sets; the merged set is the plan's own.
let merged = css_invalidation_plan_create()
let with_a = css_invalidation_plan_create()
ak.vector_append_t(&with_a.descendant_rules, CssDescendantInvalidationRule(match_set = set_a, payload = leaf))
let with_b = css_invalidation_plan_create()
ak.vector_append_t(&with_b.descendant_rules, CssDescendantInvalidationRule(match_set = set_b, payload = leaf))
css_invalidation_plan_include_all_from(merged, *with_a)
css_invalidation_plan_include_all_from(merged, *with_b)
assert(ak.vector_size(&merged.descendant_rules) == 1)
assert(ak.hash_table_size(&ak.vector_span(&merged.descendant_rules)[0].match_set.m_properties) == 2)
assert(ak.hash_table_size(&ak.vector_span(&with_a.descendant_rules)[0].match_set.m_properties) == 1)
# A whole-subtree plan drops the rules and absorbs everything after.
let whole = css_invalidation_plan_create()
whole.invalidate_whole_subtree = true
css_invalidation_plan_include_all_from(merged, *whole)
assert(merged.invalidate_whole_subtree and ak.vector_is_empty(&merged.descendant_rules))
css_invalidation_plan_include_all_from(merged, *first)
assert(ak.vector_is_empty(&merged.sibling_rules))
test "RequiredInvalidationAfterStyleChange: |=, is_none, is_full and full()":
var invalidation: CssRequiredInvalidationAfterStyleChange
assert(css_required_invalidation_after_style_change_is_none(&invalidation))
css_required_invalidation_after_style_change_or_assign(&invalidation, CssRequiredInvalidationAfterStyleChange(repaint = true))
assert(invalidation.repaint and not css_required_invalidation_after_style_change_is_none(&invalidation))
let full = css_required_invalidation_after_style_change_full()
assert(css_required_invalidation_after_style_change_is_full(&full) and not full.rebuild_accumulated_visual_contexts)
css_required_invalidation_after_style_change_or_assign(&invalidation, full)
assert(css_required_invalidation_after_style_change_is_full(&invalidation))
test "invalidation reasons: names and the reasons that cannot affect :has()":
assert(test_r42_view_is(css_invalidation_to_string(DomStyleInvalidationReason.htmli_frame_element_geometry_change), "HTMLIFrameElementGeometryChange"))
assert(test_r42_view_is(css_invalidation_to_string(DomStyleInvalidationReason.style_sheet_replace), "StyleSheetReplace"))
assert(not css_invalidation_reason_may_affect_has_selectors(DomStyleInvalidationReason.css_font_loaded))
assert(not css_invalidation_reason_may_affect_has_selectors(DomStyleInvalidationReason.navigable_set_viewport_size))
assert(css_invalidation_reason_may_affect_has_selectors(DomStyleInvalidationReason.element_attribute_change))
# mark: Scenarios ===============================================================================
test "scenario: createElement, appendChild, an attribute and classList through the DOM's entry points invalidate style":
let (vm, realm, _) = test_html_setup()
defer web_test_destroy_vm(vm)
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
test_media_invalidation_install_user_agent_sheets(realm)
defer test_style_computer_release_user_agent_sheets()
let document = test_outcome_document(realm)
let root = dom_document_create_element(document, ak.string_from_str("section"), StringOrDomElementCreationOptions.string(ak.string_from_str(""))) else trap("createElement")
let widget = dom_document_create_element(document, ak.string_from_str("x-widget"), StringOrDomElementCreationOptions.string(ak.string_from_str(""))) else trap("createElement")
let item = dom_document_create_element(document, ak.string_from_str("article"), StringOrDomElementCreationOptions.string(ak.string_from_str(""))) else trap("createElement")
_ = dom_node_append_child(document.dom_node(), root.dom_node()) else trap("appendChild")
_ = dom_node_append_child(root.dom_node(), widget.dom_node()) else trap("appendChild")
_ = dom_node_append_child(root.dom_node(), item.dom_node()) else trap("appendChild")
# Appending to the document marks it for a full style update; children of a marked subtree add nothing.
assert(dom_node_entire_subtree_needs_style_update(root.dom_node()) or dom_document_needs_full_style_update(document))
assert(not dom_element_is_defined(widget) and dom_element_is_defined(item))
let sheet = parse_css_stylesheet(test_media_invalidation_params(realm), ak.sv(".on article { color: red } x-widget[open] { color: blue }"))
ak.vector_append_t(&dom_document_style_sheets(document).m_sheets, sheet)
_ = ak.hash_table_set(&sheet.m_owning_documents_or_shadow_roots, document.dom_node())
css_style_scope_build_rule_cache_if_needed(dom_document_style_scope(document))
test_outcome_collect_involvement_metadata(document, sheet)
test_outcome_clear_style_flags(document)
# Setting an attribute on the widget (Element::set_attribute_value; the bindings' setAttribute stops in
# TrustedTypes, phase 3): the [open] rule invalidates the widget only.
dom_element_set_attribute_value(widget, ak.fly_string_from_str("open"), ak.string_from_str(""))
css_style_invalidator_invalidate(dom_document_style_invalidator(document), document.dom_node())
assert(dom_node_needs_style_update(widget.dom_node()) and not dom_node_needs_style_update(item.dom_node()))
assert(dom_node_child_needs_style_update(root.dom_node()))
# classList.add("on") on the root: `.on article` reaches the article through a descendant rule.
test_outcome_clear_style_flags(document)
var tokens: ak.Vector[ak.String]
ak.vector_append_t(&tokens, ak.string_from_str("on"))
try dom_token_list_add(dom_element_class_list(root), tokens) catch:
trap("classList.add threw")
css_style_invalidator_invalidate(dom_document_style_invalidator(document), document.dom_node())
assert(dom_node_needs_style_update(item.dom_node()) and not dom_node_needs_style_update(widget.dom_node()))
assert(not dom_node_needs_style_update(root.dom_node()))