Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / tests_css_sheets_2.lucb

#==============================================================================================
#
#   tests_css_sheets_2 - the focused oracle cases: CSSOM objects made directly
#
#   DESCRIPTION:
#       The oracle's focused modes (oracles/luce-browser-engine/css_sheets, cases.txt from
#       "properties" on): declaration blocks with no declarations and the resolved style,
#       descriptor blocks and @font-face, @counter-style names, @property, @container
#       conditions and effective rules, @import, keyframes, nested declarations, MediaList and
#       StyleSheet state, and the name predicates. tests_css_sheets runs them with the other
#       cases.
#
#==============================================================================================

## One formatted output line of a focused case, at indentation 1.
func test_css_sheets_formatted(out: ak.StringBuilder*, fmtstr: str, arguments: const ak.TypeErasedParameter[]):
    var text = ak.string_builder_new()
    dump_appendff(&text, fmtstr, arguments)
    test_css_sheets_line(out, 1, ak.string_builder_string_view(&text))

## The dump of a rule as `dump: ` lines (the oracle's dump loops).
func test_css_sheets_dump_rule(out: ak.StringBuilder*, rule: CssRule*):
    var builder = ak.string_builder_new()
    dump_rule_string_builder(&builder, rule, 1)
    test_css_sheets_dump_lines(out, ak.string_builder_string_view(&builder))

## Every line of `dumped` as a `dump: ` line.
func test_css_sheets_dump_lines(out: ak.StringBuilder*, dumped: ak.StringView):
    let lines = ak.string_view_split_view_u8(&dumped, '\n')
    for dump_line in ak.vector_span_const(&lines):
        test_css_sheets_labeled(out, "dump: ", dump_line)

## An empty CSSStyleProperties (CSSStyleProperties::create with no declarations).
func test_css_sheets_empty_properties(realm: Realm*) -> CssStyleProperties*:
    return css_style_properties_create(realm, ak.Vector[CssStyleProperty](), ak.OrderedHashMap[ak.FlyString, CssStyleProperty, ak.FlyStringTraits]())

## Whether a fallible CSSOM call succeeded (`!result.is_exception()`).
func test_css_sheets_ok(failed: bool) -> bool:
    if failed:
        _ = idl_take_pending_exception()
    return not failed

## The oracle's `properties` mode.
func test_css_sheets_properties(out: ak.StringBuilder*, realm: Realm*):
    let props = test_css_sheets_empty_properties(realm)
    let declaration = props.css_style_declaration()
    test_css_sheets_formatted(out, "length {} computed {} readonly {}", [ak.arg_u64((u64)css_style_declaration_length(declaration)), ak.arg_bool(css_style_declaration_is_computed(declaration)),
                                                                         ak.arg_bool(css_style_declaration_is_readonly(declaration))])
    let item0 = css_style_declaration_item(declaration, 0)
    let css_text = css_style_declaration_css_text(declaration)
    test_css_sheets_formatted(out, "item0 '{}' cssText '{}'", [css_arg_string(&item0), css_arg_string(&css_text)])
    let color = css_style_declaration_get_property_value(declaration, ak.fly_string_from_str("color"))
    let priority = css_style_declaration_get_property_priority(declaration, ak.fly_string_from_str("color"))
    let custom = css_style_declaration_get_property_value(declaration, ak.fly_string_from_str("--x"))
    let bogus = css_style_declaration_get_property_value(declaration, ak.fly_string_from_str("bogus"))
    test_css_sheets_formatted(out, "color '{}' priority '{}' --x '{}' bogus '{}'", [css_arg_string(&color), ak.arg_string_view(priority), css_arg_string(&custom), css_arg_string(&bogus)])
    let margin = css_style_declaration_get_property_value(declaration, ak.fly_string_from_str("margin"))
    let css_float = css_style_properties_css_float(props)
    let generated_color = bind_generated_css_style_properties_color(&props.generated_css_style_properties)
    test_css_sheets_formatted(out, "margin '{}' cssFloat '{}' generated color '{}'", [css_arg_string(&margin), css_arg_string(&css_float), css_arg_string(&generated_color)])
    let removed = css_style_declaration_remove_property(declaration, ak.fly_string_from_str("color")) else trap("MUST: remove_property")
    test_css_sheets_formatted(out, "remove color '{}'", [css_arg_string(&removed)])
    var failed = false
    css_style_declaration_set_property(declaration, ak.fly_string_from_str("color"), ak.sv(""), ak.sv("")) catch _:
        failed = true
        recover ()
    test_css_sheets_formatted(out, "set color '' ok {}", [ak.arg_bool(test_css_sheets_ok(failed))])
    failed = false
    css_style_declaration_set_property(declaration, ak.fly_string_from_str("color"), ak.sv("red"), ak.sv("bogus")) catch _:
        failed = true
        recover ()
    test_css_sheets_formatted(out, "set color priority bogus ok {}", [ak.arg_bool(test_css_sheets_ok(failed))])
    failed = false
    css_style_declaration_set_property(declaration, ak.fly_string_from_str("bogus"), ak.sv("red"), ak.sv("")) catch _:
        failed = true
        recover ()
    test_css_sheets_formatted(out, "set bogus ok {}", [ak.arg_bool(test_css_sheets_ok(failed))])
    failed = false
    bind_generated_css_style_properties_set_color(&props.generated_css_style_properties, ak.sv("")) catch _:
        failed = true
        recover ()
    test_css_sheets_formatted(out, "generated set_color '' ok {}", [ak.arg_bool(test_css_sheets_ok(failed))])
    failed = false
    css_style_declaration_set_css_text(declaration, ak.sv("")) catch _:
        failed = true
        recover ()
    let text_ok = test_css_sheets_ok(failed)
    test_css_sheets_formatted(out, "cssText '' ok {} length {}", [ak.arg_bool(text_ok), ak.arg_u64((u64)css_style_declaration_length(declaration))])
    test_css_sheets_formatted(out, "has color {} custom count {}", [ak.arg_bool(css_style_properties_has_property_property_id(props, css_data.PropertyId.color)), ak.arg_u64((u64)css_style_properties_custom_property_count(props))])
    let serialized_list = css_style_properties_serialize_a_css_value_vector(props, ak.Vector[CssStyleProperty]())
    test_css_sheets_formatted(out, "serialize list '{}'", [css_arg_string(&serialized_list)])

    let resolved = css_style_properties_create_resolved_style(realm, none)
    let resolved_declaration = resolved.css_style_declaration()
    let resolved_item0 = css_style_declaration_item(resolved_declaration, 0)
    let resolved_text = css_style_declaration_css_text(resolved_declaration)
    let resolved_color = css_style_declaration_get_property_value(resolved_declaration, ak.fly_string_from_str("color"))
    test_css_sheets_formatted(out, "resolved length {} computed {} readonly {} item0 '{}' cssText '{}' color '{}'", [ak.arg_u64((u64)css_style_declaration_length(resolved_declaration)),
                                                                                                                     ak.arg_bool(css_style_declaration_is_computed(resolved_declaration)), ak.arg_bool(css_style_declaration_is_readonly(resolved_declaration)), css_arg_string(&resolved_item0),
                                                                                                                     css_arg_string(&resolved_text), css_arg_string(&resolved_color)])
    css_style_declaration_set_property(resolved_declaration, ak.fly_string_from_str("color"), ak.sv("red"), ak.sv("")) catch _:
        test_css_sheets_print_exception(out)
        recover ()
    _ = css_style_declaration_remove_property(resolved_declaration, ak.fly_string_from_str("color")) catch _:
        test_css_sheets_print_exception(out)
        recover ak.string_from_str("")
    css_style_declaration_set_css_text(resolved_declaration, ak.sv("color: red")) catch _:
        test_css_sheets_print_exception(out)
        recover ()

## The oracle's `descriptors` mode.
func test_css_sheets_descriptors(out: ak.StringBuilder*, realm: Realm*):
    let font_face = css_css_font_face_descriptors_create(realm, ak.Vector[CssDescriptor]())
    let declaration = font_face.css_style_declaration()
    let item0 = css_style_declaration_item(declaration, 0)
    let css_text = css_style_declaration_css_text(declaration)
    let src = css_style_declaration_get_property_value(declaration, ak.fly_string_from_str("src"))
    let family = css_css_font_face_descriptors_font_family(font_face)
    let priority = css_style_declaration_get_property_priority(declaration, ak.fly_string_from_str("src"))
    test_css_sheets_formatted(out, "length {} item0 '{}' cssText '{}' src '{}' family '{}' priority '{}'", [ak.arg_u64((u64)css_style_declaration_length(declaration)), css_arg_string(&item0),
                                                                                                            css_arg_string(&css_text), css_arg_string(&src), css_arg_string(&family), ak.arg_string_view(priority)])
    var failed = false
    css_style_declaration_set_property(declaration, ak.fly_string_from_str("bogus"), ak.sv("x"), ak.sv("")) catch _:
        failed = true
        recover ()
    let bogus_ok = test_css_sheets_ok(failed)
    failed = false
    css_style_declaration_set_property(declaration, ak.fly_string_from_str("src"), ak.sv(""), ak.sv("")) catch _:
        failed = true
        recover ()
    let src_ok = test_css_sheets_ok(failed)
    let removed_src = css_style_declaration_remove_property(declaration, ak.fly_string_from_str("src")) else trap("MUST: remove_property")
    let removed_bogus = css_style_declaration_remove_property(declaration, ak.fly_string_from_str("bogus")) else trap("MUST: remove_property")
    test_css_sheets_formatted(out, "set bogus ok {} set src '' ok {} remove src '{}' remove bogus '{}'", [ak.arg_bool(bogus_ok), ak.arg_bool(src_ok), css_arg_string(&removed_src), css_arg_string(&removed_bogus)])
    failed = false
    css_style_declaration_set_css_text(declaration, ak.sv("")) catch _:
        failed = true
        recover ()
    test_css_sheets_formatted(out, "cssText '' ok {}", [ak.arg_bool(test_css_sheets_ok(failed))])
    let rule = css_font_face_rule_create(realm, font_face)
    let rule_text = css_rule_css_text(rule.css_rule())
    let parent_ok = css_style_declaration_parent_rule(declaration) == rule.css_rule()
    test_css_sheets_formatted(out, "rule valid {} text '{}' parent ok {}", [ak.arg_bool(css_font_face_rule_is_valid(rule)), css_arg_string(&rule_text), ak.arg_bool(parent_ok)])
    test_css_sheets_dump_rule(out, rule.css_rule())

    let page = css_page_descriptors_create(realm, ak.Vector[CssDescriptor]())
    let page_margin = css_page_descriptors_margin(page)
    let page_margin_top = css_page_descriptors_margin_top(page)
    let page_size = css_page_descriptors_size(page)
    test_css_sheets_formatted(out, "page margin '{}' margin-top '{}' size '{}' shorthand margin {} margin-top {} font-face src {}", [css_arg_string(&page_margin), css_arg_string(&page_margin_top),
                                                                                                                                     css_arg_string(&page_size), ak.arg_bool(css_is_shorthand(css_data.AtRuleId.page, css_descriptor_name_and_id_from_id(css_data.DescriptorId.margin))),
                                                                                                                                     ak.arg_bool(css_is_shorthand(css_data.AtRuleId.page, css_descriptor_name_and_id_from_id(css_data.DescriptorId.margin_top))),
                                                                                                                                     ak.arg_bool(css_is_shorthand(css_data.AtRuleId.font_face, css_descriptor_name_and_id_from_id(css_data.DescriptorId.src)))])
    var longhands = ak.string_builder_new()
    css_for_each_expanded_longhand(css_data.AtRuleId.page, css_descriptor_name_and_id_from_id(css_data.DescriptorId.margin), none,
                                   ak.Function2[const CssDescriptorNameAndId*, CssStyleValue*?, unit](call = test_css_sheets_longhand, context = &longhands))
    test_css_sheets_labeled(out, "page margin longhands ", ak.string_builder_string_view(&longhands))
    let page_removed = css_style_declaration_remove_property(page.css_style_declaration(), ak.fly_string_from_str("margin")) else trap("MUST: remove_property")
    test_css_sheets_formatted(out, "page remove margin '{}'", [css_arg_string(&page_removed)])
    let function = css_function_descriptors_create(realm, ak.Vector[CssDescriptor]())
    let result = css_function_descriptors_result(function)
    test_css_sheets_formatted(out, "function result '{}'", [css_arg_string(&result)])

## The longhand callback of the descriptors mode: `<name>:<value or null> `.
func test_css_sheets_longhand(context: void*?, name: const CssDescriptorNameAndId*, value: CssStyleValue*?):
    let builder = (ak.StringBuilder*)(context else trap("no builder"))
    let descriptor_name = css_descriptor_name_and_id_name(name)
    dump_appendff(builder, "{}:{} ", [css_arg_fly_string(&descriptor_name), ak.arg_str("value" if value != none else "null")])

## The oracle's `counterstyle` mode.
func test_css_sheets_counter_style(out: ak.StringBuilder*, realm: Realm*):
    let rule = css_counter_style_rule_create(realm, ak.fly_string_from_str("foo"), none, none, none, none, none, none, none, none, none, none)
    let text = css_rule_css_text(rule.css_rule())
    let name = css_counter_style_rule_name(rule)
    let system = css_counter_style_rule_system(rule)
    let symbols = css_counter_style_rule_symbols(rule)
    let speak_as = css_counter_style_rule_speak_as(rule)
    test_css_sheets_formatted(out, "text '{}' name '{}' system '{}' symbols '{}' speak-as '{}'", [css_arg_string(&text), css_arg_fly_string(&name), css_arg_fly_string(&system), css_arg_fly_string(&symbols),
                                                                                                  css_arg_fly_string(&speak_as)])
    let names: str[7] = ["none", "DISC", "Decimal", "lower-ROMAN", "Upper-Alpha", "bar", "Baz"]
    for new_name in names:
        css_counter_style_rule_set_name(rule, ak.fly_string_from_str(new_name))
        let current = css_counter_style_rule_name(rule)
        test_css_sheets_formatted(out, "set_name {} -> {}", [ak.arg_str(new_name), css_arg_fly_string(&current)])
    let candidates: str[8] = ["decimal", "DISC", "square", "circle", "disclosure-open", "disclosure-closed", "foo", "none"]
    for candidate in candidates:
        test_css_sheets_formatted(out, "non-overridable {} {}", [ak.arg_str(candidate), ak.arg_bool(css_counter_style_rule_matches_non_overridable_counter_style_name(ak.fly_string_from_str(candidate)))])

## The oracle's `property` mode.
func test_css_sheets_property(out: ak.StringBuilder*, realm: Realm*):
    let rule = css_property_rule_create(realm, ak.fly_string_from_str("--my-prop"), ak.fly_string_from_str("*"), false, none)
    let text = css_rule_css_text(rule.css_rule())
    test_css_sheets_formatted(out, "text '{}' initial '{}'", [css_arg_string(&text), ak.arg_str("value" if css_property_rule_initial_value(rule) != none else "none")])
    let rule2 = css_property_rule_create(realm, ak.fly_string_from_str("--a b"), ak.fly_string_from_str("<length> | auto"), true, none)
    let text2 = css_rule_css_text(rule2.css_rule())
    test_css_sheets_formatted(out, "text '{}' inherits {}", [css_arg_string(&text2), ak.arg_bool(css_property_rule_inherits(rule2))])
    test_css_sheets_dump_rule(out, rule2.css_rule())

## The class names of the rules a traversal visits (the container mode's callback).
func test_css_sheets_class_names(context: void*?, rule: CssRule*):
    let builder = (ak.StringBuilder*)(context else trap("no builder"))
    dump_appendff(builder, "{} ", [ak.arg_string_view(dump_class_name(rule.cell()))])

## The oracle's `container` mode.
func test_css_sheets_container(out: ak.StringBuilder*, realm: Realm*):
    var conditions: ak.Vector[CssContainerRuleCondition]
    ak.vector_append_t(&conditions, CssContainerRuleCondition(container_name = ak.fly_string_from_str("sidebar"), container_query = none))
    let no_rules = ak.Vector[CssRule*]()
    let rule = css_container_rule_create(realm, conditions, css_rule_list_create(realm, ak.vector_span_const(&no_rules)))
    let text = css_rule_css_text(rule.css_rule())
    let condition = css_condition_rule_condition_text(rule.css_condition_rule())
    let name = css_container_rule_container_name(rule)
    let query = css_container_rule_container_query(rule)
    let rule_conditions = css_container_rule_conditions(rule)
    test_css_sheets_formatted(out, "text '{}' condition '{}' name '{}' query '{}' conditions {}", [css_arg_string(&text), css_arg_string(&condition), css_arg_string(&name), css_arg_string(&query),
                                                                                                   ak.arg_u64((u64)ak.vector_size(&rule_conditions))])
    var two: ak.Vector[CssContainerRuleCondition]
    ak.vector_append_t(&two, CssContainerRuleCondition(container_name = ak.fly_string_from_str("a b"), container_query = none))
    ak.vector_append_t(&two, CssContainerRuleCondition(container_name = none, container_query = none))
    let rule2 = css_container_rule_create(realm, two, css_rule_list_create(realm, ak.vector_span_const(&no_rules)))
    let text2 = css_rule_css_text(rule2.css_rule())
    let name2 = css_container_rule_container_name(rule2)
    let conditions2 = css_container_rule_conditions(rule2)
    test_css_sheets_formatted(out, "text '{}' name '{}' conditions {}", [css_arg_string(&text2), css_arg_string(&name2), ak.arg_u64((u64)ak.vector_size(&conditions2))])
    let inner = parse_css_stylesheet(test_css_sheets_params(realm), ak.sv("@layer x; a {} @layer y { b {} } @page {}"))
    let children = ak.vector_clone(&css_css_style_sheet_rules(inner).m_rules)
    let rule3 = css_container_rule_create(realm, ak.Vector[CssContainerRuleCondition](), css_rule_list_create(realm, ak.vector_span_const(&children)))
    var visited = ak.string_builder_new()
    css_grouping_rule_for_each_effective_rule(rule3.css_grouping_rule(), TraversalOrder.preorder, ak.Function1[CssRule*, unit](call = test_css_sheets_class_names, context = &visited))
    test_css_sheets_labeled(out, "effective preorder ", ak.string_builder_string_view(&visited))
    var post = ak.string_builder_new()
    css_grouping_rule_for_each_effective_rule(rule3.css_grouping_rule(), TraversalOrder.postorder, ak.Function1[CssRule*, unit](call = test_css_sheets_class_names, context = &post))
    test_css_sheets_labeled(out, "effective postorder ", ak.string_builder_string_view(&post))

## The oracle's `import` mode.
func test_css_sheets_import(out: ak.StringBuilder*, realm: Realm*):
    let layers: (ak.FlyString?)[3] = [none, ak.fly_string_from_str(""), ak.fly_string_from_str("x.y")]
    for layer in layers:
        var url: CssUrl = ---
        css_url_construct(&url, ak.string_from_str("foo.css"), CssUrlType.url, ak.Vector[CssRequestUrlModifier]())
        let rule = css_import_rule_create(realm, url, none, layer, none, css_media_list_create(realm, ak.Vector[CssMediaQuery*]()))
        let text = css_rule_css_text(rule.css_rule())
        let href = css_import_rule_href(rule)
        var layer_name = ak.fly_string_from_str("null")
        if let name = css_import_rule_layer_name(rule):
            layer_name = name
        var supports_text = ak.string_from_str("null")
        if let supports = css_import_rule_supports_text(rule):
            supports_text = supports
        let state = css_css_style_sheet_loading_state_name(css_style_sheet_subresource_loading_state(&rule.subresource))
        test_css_sheets_formatted(out, "text '{}' href '{}' layerName '{}' supportsText '{}' matches {} state {}", [css_arg_string(&text), css_arg_string(&href), css_arg_fly_string(&layer_name),
                                                                                                                    css_arg_string(&supports_text), ak.arg_bool(css_import_rule_matches(rule)), ak.arg_string_view(state)])
        var builder = ak.string_builder_new()
        dump_rule_string_builder(&builder, rule.css_rule(), 1)
        let dumped = ak.string_builder_string_view(&builder)
        let lines = ak.string_view_split_view_u8(&dumped, '\n')
        for dump_line in ak.vector_span_const(&lines):
            if ak.string_view_starts_with_string_view(&dump_line, ak.sv("    Layer: `")):
                test_css_sheets_labeled(out, "dump: ", ak.sv("    Layer: <anonymous>"))
            else:
                test_css_sheets_labeled(out, "dump: ", dump_line)

## The oracle's `keyframe` mode.
func test_css_sheets_keyframe(out: ak.StringBuilder*, realm: Realm*):
    let rule = css_keyframe_rule_create(realm, css_percentage_new(50.0), test_css_sheets_empty_properties(realm))
    let text = css_rule_css_text(rule.css_rule())
    let key = css_keyframe_rule_key_text(rule)
    test_css_sheets_formatted(out, "text '{}' key '{}'", [css_arg_string(&text), css_arg_string(&key)])
    let rule2 = css_keyframe_rule_create(realm, css_percentage_new(12.5), test_css_sheets_empty_properties(realm))
    let text2 = css_rule_css_text(rule2.css_rule())
    let key2 = css_keyframe_rule_key_text(rule2)
    test_css_sheets_formatted(out, "text '{}' key '{}'", [css_arg_string(&text2), css_arg_string(&key2)])
    let frames: (CssRule*)[2] = [rule.css_rule(), rule2.css_rule()]
    let keyframes = css_keyframes_rule_create(realm, ak.fly_string_from_str("spin"), css_rule_list_create(realm, frames))
    let keyframes_text = css_rule_css_text(keyframes.css_rule())
    let parent_ok = css_rule_parent_rule(rule.css_rule()) == keyframes.css_rule()
    test_css_sheets_formatted(out, "text '{}' length {} parent ok {}", [css_arg_string(&keyframes_text), ak.arg_u64((u64)css_keyframes_rule_length(keyframes)), ak.arg_bool(parent_ok)])
    test_css_sheets_dump_rule(out, keyframes.css_rule())

## The oracle's `names` mode.
func test_css_sheets_names(out: ak.StringBuilder*, vm: Vm*):
    let margin_names: str[8] = ["top-left-corner", "TOP-LEFT", "top-center", "right-bottom", "left-middle", "top", "bottom-middle", ""]
    for name in margin_names:
        test_css_sheets_formatted(out, "margin {} {}", [ak.arg_str(name), ak.arg_bool(css_is_margin_rule_name(ak.sv(name)))])
    let feature_names: str[9] = ["stylistic", "historical-forms", "styleset", "character-variant", "swash", "ornaments", "annotation", "Swash", "font"]
    for name in feature_names:
        test_css_sheets_formatted(out, "feature {} {}", [ak.arg_str(name), ak.arg_bool(css_font_feature_values_rule_is_font_feature_value_type_at_keyword(ak.fly_string_from_str(name)))])
    let types: CssStyleSheetIdentifierType[5] = [.style_element, .link_element, .import_rule, .user_agent, .user_style]
    for type_ in types:
        let name = css_style_sheet_identifier_type_to_string(type_)
        let parsed = css_style_sheet_identifier_type_from_string(name) else trap("a type")
        test_css_sheets_formatted(out, "identifier {} {}", [ak.arg_string_view(name), ak.arg_u64((u64)parsed)])
    test_css_sheets_formatted(out, "identifier bogus {}", [ak.arg_bool(css_style_sheet_identifier_type_from_string(ak.sv("bogus")) != none)])
    let states: CssStyleSheetLoadingState[4] = [.unloaded, .loading, .loaded, .error_]
    for state in states:
        test_css_sheets_formatted(out, "loading state {}", [ak.arg_string_view(css_css_style_sheet_loading_state_name(state))])
    let idents: str[6] = ["a", "a b", "1x", "-", "--x", "é"]
    for ident in idents:
        let escaped = css_escape(vm, ak.sv(ident)) else trap("MUST: escape")
        test_css_sheets_formatted(out, "escape {}", [css_arg_string(&escaped)])

## The oracle's `nested` mode.
func test_css_sheets_nested(out: ak.StringBuilder*, realm: Realm*):
    let declarations = css_nested_declarations_create_css_style_properties(realm, test_css_sheets_empty_properties(realm))
    let text = css_rule_css_text(declarations.css_rule())
    let parent_ok = css_style_declaration_parent_rule(css_nested_declarations_declaration(declarations).css_style_declaration()) == declarations.css_rule()
    test_css_sheets_formatted(out, "text '{}' parent ok {}", [css_arg_string(&text), ak.arg_bool(parent_ok)])
    test_css_sheets_dump_rule(out, declarations.css_rule())

## The oracle's `media` mode (`sheet` is the case's empty sheet).
func test_css_sheets_media(out: ak.StringBuilder*, realm: Realm*, sheet: CssCssStyleSheet*):
    let media = css_media_list_create(realm, ak.Vector[CssMediaQuery*]())
    test_css_sheets_formatted(out, "length {} matches {} item0 {}", [ak.arg_u64((u64)css_media_list_length(media)), ak.arg_bool(css_media_list_matches(media)), ak.arg_str("value" if css_media_list_item(media, 0) != none else "none")])
    css_media_list_set_media_text(media, ak.sv(""))
    test_css_sheets_formatted(out, "after '' length {}", [ak.arg_u64((u64)css_media_list_length(media))])
    var dumped = ak.string_builder_new()
    css_media_list_dump(media, &dumped, 1)
    test_css_sheets_dump_lines(out, ak.string_builder_string_view(&dumped))
    let style_sheet = sheet.css_style_sheet()
    let type_ = css_style_sheet_type(style_sheet)
    test_css_sheets_formatted(out, "sheet type {} disabled {} alternate {} origin-clean {} href {} title {}", [css_arg_string(&type_), ak.arg_bool(css_style_sheet_disabled(style_sheet)),
                                                                                                               ak.arg_bool(css_style_sheet_is_alternate(style_sheet)), ak.arg_bool(css_style_sheet_is_origin_clean(style_sheet)), ak.arg_str("value" if css_style_sheet_href(style_sheet) != none else "none"),
                                                                                                               ak.arg_str("value" if css_style_sheet_title_for_bindings(style_sheet) != none else "none")])
    css_style_sheet_set_title(style_sheet, ak.string_from_str("t"))
    css_style_sheet_set_location(style_sheet, web_url.parser_basic_parse(ak.sv("https://example.com/a/b.css")))
    let title = css_style_sheet_title_for_bindings(style_sheet) else trap("a title")
    let href = css_style_sheet_href(style_sheet) else trap("an href")
    test_css_sheets_formatted(out, "title {} href {} loading {}", [css_arg_string(&title), css_arg_string(&href), ak.arg_string_view(css_css_style_sheet_loading_state_name(css_css_style_sheet_loading_state(sheet)))])

## Run a focused mode; false when `mode` is not one.
func test_css_sheets_run_focused(out: ak.StringBuilder*, vm: Vm*, realm: Realm*, mode: str, sheet: CssCssStyleSheet*) -> bool:
    if mode == "properties":
        test_css_sheets_properties(out, realm)
    elif mode == "descriptors":
        test_css_sheets_descriptors(out, realm)
    elif mode == "counterstyle":
        test_css_sheets_counter_style(out, realm)
    elif mode == "property":
        test_css_sheets_property(out, realm)
    elif mode == "container":
        test_css_sheets_container(out, realm)
    elif mode == "import":
        test_css_sheets_import(out, realm)
    elif mode == "keyframe":
        test_css_sheets_keyframe(out, realm)
    elif mode == "names":
        test_css_sheets_names(out, vm)
    elif mode == "nested":
        test_css_sheets_nested(out, realm)
    elif mode == "media":
        test_css_sheets_media(out, realm, sheet)
    else:
        return false
    return true