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(¤t)])
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