Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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(&params, 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()))