From 86575bba1b50e772d347f5e0b4884cfb9c588971 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Tue, 11 Jun 2019 12:41:44 +0900 Subject: [PATCH 01/11] Run module tests --- tests/wpt/include.ini | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/wpt/include.ini b/tests/wpt/include.ini index 2f6620956402..f11d0d0baa41 100644 --- a/tests/wpt/include.ini +++ b/tests/wpt/include.ini @@ -116,7 +116,11 @@ skip: true [json-module] skip: true [module] - skip: true + skip: false + [dynamic-import] + skip: true + [import-meta] + skip: true [js] skip: false [mediasession] From f2007751dd12016bc01fdbe2788322be2eae0d84 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Wed, 5 Jun 2019 22:20:10 +0900 Subject: [PATCH 02/11] Scaffold module script --- components/script/dom/globalscope.rs | 30 + components/script/dom/htmlscriptelement.rs | 242 +++- components/script/dom/promise.rs | 2 +- components/script/lib.rs | 2 + components/script/script_module.rs | 1404 ++++++++++++++++++++ components/script/script_runtime.rs | 3 + 6 files changed, 1620 insertions(+), 63 deletions(-) create mode 100644 components/script/script_module.rs diff --git a/components/script/dom/globalscope.rs b/components/script/dom/globalscope.rs index f6937427edaa..04f8d948a24d 100644 --- a/components/script/dom/globalscope.rs +++ b/components/script/dom/globalscope.rs @@ -24,6 +24,7 @@ use crate::dom::event::{Event, EventBubbles, EventCancelable, EventStatus}; use crate::dom::eventsource::EventSource; use crate::dom::eventtarget::EventTarget; use crate::dom::file::File; +use crate::dom::htmlscriptelement::ScriptId; use crate::dom::messageevent::MessageEvent; use crate::dom::messageport::MessagePort; use crate::dom::paintworkletglobalscope::PaintWorkletGlobalScope; @@ -32,6 +33,7 @@ use crate::dom::window::Window; use crate::dom::workerglobalscope::WorkerGlobalScope; use crate::dom::workletglobalscope::WorkletGlobalScope; use crate::microtask::{Microtask, MicrotaskQueue}; +use crate::script_module::ModuleTree; use crate::script_runtime::{CommonScriptMsg, JSContext as SafeJSContext, ScriptChan, ScriptPort}; use crate::script_thread::{MainThreadScriptChan, ScriptThread}; use crate::task::TaskCanceller; @@ -119,6 +121,14 @@ pub struct GlobalScope { /// Timers used by the Console API. console_timers: DomRefCell>, + /// module map is used when importing JavaScript modules + /// https://html.spec.whatwg.org/multipage/#concept-settings-object-module-map + #[ignore_malloc_size_of = "mozjs"] + module_map: DomRefCell>>, + + #[ignore_malloc_size_of = "mozjs"] + inline_module_map: DomRefCell>>, + /// For providing instructions to an optional devtools server. #[ignore_malloc_size_of = "channels are hard"] devtools_chan: Option>, @@ -391,6 +401,8 @@ impl GlobalScope { pipeline_id, devtools_wants_updates: Default::default(), console_timers: DomRefCell::new(Default::default()), + module_map: DomRefCell::new(Default::default()), + inline_module_map: DomRefCell::new(Default::default()), devtools_chan, mem_profiler_chan, time_profiler_chan, @@ -1357,6 +1369,24 @@ impl GlobalScope { &self.consumed_rejections } + pub fn set_module_map(&self, url: ServoUrl, module: ModuleTree) { + self.module_map.borrow_mut().insert(url, Rc::new(module)); + } + + pub fn get_module_map(&self) -> &DomRefCell>> { + &self.module_map + } + + pub fn set_inline_module_map(&self, script_id: ScriptId, module: ModuleTree) { + self.inline_module_map + .borrow_mut() + .insert(script_id, Rc::new(module)); + } + + pub fn get_inline_module_map(&self) -> &DomRefCell>> { + &self.inline_module_map + } + #[allow(unsafe_code)] pub fn get_cx(&self) -> SafeJSContext { unsafe { SafeJSContext::from_ptr(Runtime::get()) } diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs index fdeca285e304..b594660a8350 100644 --- a/components/script/dom/htmlscriptelement.rs +++ b/components/script/dom/htmlscriptelement.rs @@ -12,6 +12,7 @@ use crate::dom::bindings::inheritance::Castable; use crate::dom::bindings::refcounted::Trusted; use crate::dom::bindings::reflector::DomObject; use crate::dom::bindings::root::{Dom, DomRoot}; +use crate::dom::bindings::settings_stack::AutoEntryScript; use crate::dom::bindings::str::{DOMString, USVString}; use crate::dom::document::Document; use crate::dom::element::{ @@ -27,6 +28,8 @@ use crate::dom::performanceresourcetiming::InitiatorType; use crate::dom::virtualmethods::VirtualMethods; use crate::fetch::create_a_potential_CORS_request; use crate::network_listener::{self, NetworkListener, PreInvoke, ResourceTimingListener}; +use crate::script_module::fetch_inline_module_script; +use crate::script_module::{fetch_external_module_script, ModuleOwner}; use content_security_policy as csp; use dom_struct::dom_struct; use encoding_rs::Encoding; @@ -51,6 +54,10 @@ use std::sync::{Arc, Mutex}; use style::str::{StaticStringVec, HTML_SPACE_CHARACTERS}; use uuid::Uuid; +/// An unique id for script element. +#[derive(Clone, Copy, Debug, Eq, Hash, JSTraceable, PartialEq)] +pub struct ScriptId(Uuid); + #[dom_struct] pub struct HTMLScriptElement { htmlelement: HTMLElement, @@ -71,6 +78,10 @@ pub struct HTMLScriptElement { /// Track line line_number line_number: u64, + + /// Unique id for each script element + #[ignore_malloc_size_of = "Defined in uuid"] + id: ScriptId, } impl HTMLScriptElement { @@ -81,6 +92,7 @@ impl HTMLScriptElement { creator: ElementCreator, ) -> HTMLScriptElement { HTMLScriptElement { + id: ScriptId(Uuid::new_v4()), htmlelement: HTMLElement::new_inherited(local_name, prefix, document), already_started: Cell::new(false), parser_inserted: Cell::new(creator.is_parser_created()), @@ -105,11 +117,15 @@ impl HTMLScriptElement { HTMLScriptElementBinding::Wrap, ) } + + pub fn get_script_id(&self) -> ScriptId { + self.id.clone() + } } /// Supported script types as defined by /// . -static SCRIPT_JS_MIMES: StaticStringVec = &[ +pub static SCRIPT_JS_MIMES: StaticStringVec = &[ "application/ecmascript", "application/javascript", "application/x-ecmascript", @@ -143,7 +159,7 @@ pub struct ScriptOrigin { } impl ScriptOrigin { - fn internal(text: DOMString, url: ServoUrl, type_: ScriptType) -> ScriptOrigin { + pub fn internal(text: DOMString, url: ServoUrl, type_: ScriptType) -> ScriptOrigin { ScriptOrigin { text: text, url: url, @@ -152,7 +168,7 @@ impl ScriptOrigin { } } - fn external(text: DOMString, url: ServoUrl, type_: ScriptType) -> ScriptOrigin { + pub fn external(text: DOMString, url: ServoUrl, type_: ScriptType) -> ScriptOrigin { ScriptOrigin { text: text, url: url, @@ -160,6 +176,10 @@ impl ScriptOrigin { type_, } } + + pub fn text(&self) -> DOMString { + self.text.clone() + } } pub type ScriptResult = Result; @@ -441,23 +461,25 @@ impl HTMLScriptElement { } // Step 14. - let for_attribute = element.get_attribute(&ns!(), &local_name!("for")); - let event_attribute = element.get_attribute(&ns!(), &local_name!("event")); - match (for_attribute, event_attribute) { - (Some(ref for_attribute), Some(ref event_attribute)) => { - let for_value = for_attribute.value().to_ascii_lowercase(); - let for_value = for_value.trim_matches(HTML_SPACE_CHARACTERS); - if for_value != "window" { - return; - } + if script_type == ScriptType::Classic { + let for_attribute = element.get_attribute(&ns!(), &local_name!("for")); + let event_attribute = element.get_attribute(&ns!(), &local_name!("event")); + match (for_attribute, event_attribute) { + (Some(ref for_attribute), Some(ref event_attribute)) => { + let for_value = for_attribute.value().to_ascii_lowercase(); + let for_value = for_value.trim_matches(HTML_SPACE_CHARACTERS); + if for_value != "window" { + return; + } - let event_value = event_attribute.value().to_ascii_lowercase(); - let event_value = event_value.trim_matches(HTML_SPACE_CHARACTERS); - if event_value != "onload" && event_value != "onload()" { - return; - } - }, - (_, _) => (), + let event_value = event_attribute.value().to_ascii_lowercase(); + let event_value = event_value.trim_matches(HTML_SPACE_CHARACTERS); + if event_value != "onload" && event_value != "onload()" { + return; + } + }, + (_, _) => (), + } } // Step 15. @@ -514,6 +536,7 @@ impl HTMLScriptElement { }, }; + // Step 24.6. match script_type { ScriptType::Classic => { // Preparation for step 26. @@ -555,50 +578,66 @@ impl HTMLScriptElement { } }, ScriptType::Module => { - warn!( - "{} is a module script. It should be fixed after #23545 landed.", - url.clone() + fetch_external_module_script( + ModuleOwner::Window(Trusted::new(self)), + url.clone(), + Destination::Script, ); - self.global().issue_page_warning(&format!( - "Module scripts are not supported; {} will not be executed.", - url.clone() - )); + + if !r#async && was_parser_inserted { + doc.add_deferred_script(self); + } else if !r#async && !self.non_blocking.get() { + doc.push_asap_in_order_script(self); + } else { + doc.add_asap_script(self); + }; }, } } else { // Step 25. assert!(!text.is_empty()); - // Step 25-1. + // Step 25-1. & 25-2. let result = Ok(ScriptOrigin::internal( text.clone(), base_url.clone(), script_type.clone(), )); - // TODO: Step 25-2. - if let ScriptType::Module = script_type { - warn!( - "{} is a module script. It should be fixed after #23545 landed.", - base_url.clone() - ); - self.global().issue_page_warning( - "Module scripts are not supported; ignoring inline module script.", - ); - return; - } + // Step 25-2. + match script_type { + ScriptType::Classic => { + if was_parser_inserted && + doc.get_current_parser() + .map_or(false, |parser| parser.script_nesting_level() <= 1) && + doc.get_script_blocking_stylesheets_count() > 0 + { + // Step 26.h: classic, has no src, was parser-inserted, is blocked on stylesheet. + doc.set_pending_parsing_blocking_script(self, Some(result)); + } else { + // Step 26.i: otherwise. + self.execute(result); + } + }, + ScriptType::Module => { + // We should add inline module script elements + // into those vectors in case that there's no + // descendants in the inline module script. + if !r#async && was_parser_inserted { + doc.add_deferred_script(self); + } else if !r#async && !self.non_blocking.get() { + doc.push_asap_in_order_script(self); + } else { + doc.add_asap_script(self); + }; - // Step 26. - if was_parser_inserted && - doc.get_current_parser() - .map_or(false, |parser| parser.script_nesting_level() <= 1) && - doc.get_script_blocking_stylesheets_count() > 0 - { - // Step 26.h: classic, has no src, was parser-inserted, is blocked on stylesheet. - doc.set_pending_parsing_blocking_script(self, Some(result)); - } else { - // Step 26.i: otherwise. - self.execute(result); + fetch_inline_module_script( + ModuleOwner::Window(Trusted::new(self)), + text.clone(), + base_url.clone(), + self.id.clone(), + ); + }, } } } @@ -656,7 +695,7 @@ impl HTMLScriptElement { } /// - pub fn execute(&self, result: Result) { + pub fn execute(&self, result: ScriptResult) { // Step 1. let doc = document_from_node(self); if self.parser_inserted.get() && &*doc != &*self.parser_document { @@ -674,10 +713,12 @@ impl HTMLScriptElement { Ok(script) => script, }; - self.unminify_js(&mut script); + if script.type_ == ScriptType::Classic { + self.unminify_js(&mut script); + } // Step 3. - let neutralized_doc = if script.external { + let neutralized_doc = if script.external || script.type_ == ScriptType::Module { debug!("loading external script, url = {}", script.url); let doc = document_from_node(self); doc.incr_ignore_destructive_writes_counter(); @@ -690,21 +731,24 @@ impl HTMLScriptElement { let document = document_from_node(self); let old_script = document.GetCurrentScript(); - // Step 5.a.1. - document.set_current_script(Some(self)); - - // Step 5.a.2. - self.run_a_classic_script(&script); - - // Step 6. - document.set_current_script(old_script.as_deref()); + match script.type_ { + ScriptType::Classic => { + document.set_current_script(Some(self)); + self.run_a_classic_script(&script); + document.set_current_script(old_script.as_deref()); + }, + ScriptType::Module => { + assert!(old_script.is_none()); + self.run_a_module_script(&script, false); + }, + } - // Step 7. + // Step 5. if let Some(doc) = neutralized_doc { doc.decr_ignore_destructive_writes_counter(); } - // Step 8. + // Step 6. if script.external { self.dispatch_load_event(); } @@ -736,6 +780,72 @@ impl HTMLScriptElement { ); } + #[allow(unsafe_code)] + /// https://html.spec.whatwg.org/multipage/#run-a-module-script + pub fn run_a_module_script(&self, script: &ScriptOrigin, _rethrow_errors: bool) { + // TODO use a settings object rather than this element's document/window + // Step 2 + let document = document_from_node(self); + if !document.is_fully_active() || !document.is_scripting_enabled() { + return; + } + + // Step 4 + let window = window_from_node(self); + let global = window.upcast::(); + let _aes = AutoEntryScript::new(&global); + + if script.external { + let module_map = global.get_module_map().borrow(); + + if let Some(module_tree) = module_map.get(&script.url) { + // Step 6. + { + let module_error = module_tree.get_error().borrow(); + if module_error.is_some() { + module_tree.report_error(&global); + return; + } + } + + let module_record = module_tree.get_record().borrow(); + if let Some(record) = &*module_record { + let evaluated = module_tree.execute_module(global, record.handle()); + + if let Err(exception) = evaluated { + module_tree.set_error(Some(exception.clone())); + module_tree.report_error(&global); + return; + } + } + } + } else { + let inline_module_map = global.get_inline_module_map().borrow(); + + if let Some(module_tree) = inline_module_map.get(&self.id.clone()) { + // Step 6. + { + let module_error = module_tree.get_error().borrow(); + if module_error.is_some() { + module_tree.report_error(&global); + return; + } + } + + let module_record = module_tree.get_record().borrow(); + if let Some(record) = &*module_record { + let evaluated = module_tree.execute_module(global, record.handle()); + + if let Err(exception) = evaluated { + module_tree.set_error(Some(exception.clone())); + module_tree.report_error(&global); + return; + } + } + } + } + } + pub fn queue_error_event(&self) { let window = window_from_node(self); window @@ -818,10 +928,18 @@ impl HTMLScriptElement { self.parser_inserted.set(parser_inserted); } + pub fn get_parser_inserted(&self) -> bool { + self.parser_inserted.get() + } + pub fn set_already_started(&self, already_started: bool) { self.already_started.set(already_started); } + pub fn get_non_blocking(&self) -> bool { + self.non_blocking.get() + } + fn dispatch_event( &self, type_: Atom, diff --git a/components/script/dom/promise.rs b/components/script/dom/promise.rs index d2e209b98dd3..785c1be89395 100644 --- a/components/script/dom/promise.rs +++ b/components/script/dom/promise.rs @@ -225,7 +225,7 @@ impl Promise { } #[allow(unsafe_code)] - fn promise_obj(&self) -> HandleObject { + pub fn promise_obj(&self) -> HandleObject { let obj = self.reflector().get_jsobject(); unsafe { assert!(IsPromiseObject(obj)); diff --git a/components/script/lib.rs b/components/script/lib.rs index 79c0657b9967..2ae7f76923ae 100644 --- a/components/script/lib.rs +++ b/components/script/lib.rs @@ -83,6 +83,8 @@ mod microtask; #[warn(deprecated)] mod network_listener; #[warn(deprecated)] +mod script_module; +#[warn(deprecated)] pub mod script_runtime; #[warn(deprecated)] #[allow(unsafe_code)] diff --git a/components/script/script_module.rs b/components/script/script_module.rs new file mode 100644 index 000000000000..9a1c297aac07 --- /dev/null +++ b/components/script/script_module.rs @@ -0,0 +1,1404 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! The script module mod contains common traits and structs +//! related to `type=module` for script thread or worker threads. + +use crate::compartments::{enter_realm, AlreadyInCompartment, InCompartment}; +use crate::document_loader::LoadType; +use crate::dom::bindings::cell::DomRefCell; +use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowBinding::WindowMethods; +use crate::dom::bindings::conversions::jsstring_to_str; +use crate::dom::bindings::error::report_pending_exception; +use crate::dom::bindings::error::Error; +use crate::dom::bindings::inheritance::Castable; +use crate::dom::bindings::refcounted::{Trusted, TrustedPromise}; +use crate::dom::bindings::reflector::DomObject; +use crate::dom::bindings::root::DomRoot; +use crate::dom::bindings::settings_stack::AutoIncumbentScript; +use crate::dom::bindings::str::DOMString; +use crate::dom::bindings::trace::RootedTraceableBox; +use crate::dom::document::Document; +use crate::dom::element::Element; +use crate::dom::globalscope::GlobalScope; +use crate::dom::htmlscriptelement::{HTMLScriptElement, ScriptId}; +use crate::dom::htmlscriptelement::{ScriptOrigin, ScriptType, SCRIPT_JS_MIMES}; +use crate::dom::node::document_from_node; +use crate::dom::performanceresourcetiming::InitiatorType; +use crate::dom::promise::Promise; +use crate::dom::promisenativehandler::{Callback, PromiseNativeHandler}; +use crate::dom::window::Window; +use crate::dom::worker::TrustedWorkerAddress; +use crate::network_listener::{self, NetworkListener}; +use crate::network_listener::{PreInvoke, ResourceTimingListener}; +use crate::task::TaskBox; +use crate::task_source::TaskSourceName; +use encoding_rs::UTF_8; +use hyper_serde::Serde; +use ipc_channel::ipc; +use ipc_channel::router::ROUTER; +use js::glue::{AppendToAutoObjectVector, CreateAutoObjectVector}; +use js::jsapi::Handle as RawHandle; +use js::jsapi::HandleObject; +use js::jsapi::HandleValue as RawHandleValue; +use js::jsapi::{AutoObjectVector, JSAutoRealm, JSObject, JSString}; +use js::jsapi::{GetModuleResolveHook, JSRuntime, SetModuleResolveHook}; +use js::jsapi::{GetRequestedModules, SetModuleMetadataHook}; +use js::jsapi::{GetWaitForAllPromise, ModuleEvaluate, ModuleInstantiate, SourceText}; +use js::jsapi::{Heap, JSContext, JS_ClearPendingException, SetModulePrivate}; +use js::jsapi::{SetModuleDynamicImportHook, SetScriptPrivateReferenceHooks}; +use js::jsval::{JSVal, PrivateValue, UndefinedValue}; +use js::rust::jsapi_wrapped::{CompileModule, JS_GetArrayLength, JS_GetElement}; +use js::rust::jsapi_wrapped::{GetRequestedModuleSpecifier, JS_GetPendingException}; +use js::rust::wrappers::JS_SetPendingException; +use js::rust::CompileOptionsWrapper; +use js::rust::IntoHandle; +use js::rust::{Handle, HandleValue}; +use net_traits::request::{Destination, ParserMetadata, Referrer, RequestBuilder, RequestMode}; +use net_traits::{FetchMetadata, Metadata}; +use net_traits::{FetchResponseListener, NetworkError}; +use net_traits::{ResourceFetchTiming, ResourceTimingType}; +use servo_url::ServoUrl; +use std::cmp::Ordering; +use std::collections::{HashMap, HashSet}; +use std::ffi; +use std::marker::PhantomData; +use std::ptr; +use std::rc::Rc; +use std::sync::{Arc, Mutex}; +use url::ParseError as UrlParseError; + +pub fn get_source_text(source: &[u16]) -> SourceText { + SourceText { + units_: source.as_ptr() as *const _, + length_: source.len() as u32, + ownsUnits_: false, + _phantom_0: PhantomData, + } +} + +#[allow(unsafe_code)] +unsafe fn gen_type_error(global: &GlobalScope, string: String) -> ModuleError { + rooted!(in(*global.get_cx()) let mut thrown = UndefinedValue()); + Error::Type(string).to_jsval(*global.get_cx(), &global, thrown.handle_mut()); + + return ModuleError::RawException(RootedTraceableBox::from_box(Heap::boxed(thrown.get()))); +} + +#[derive(JSTraceable)] +pub struct ModuleObject(Box>); + +impl ModuleObject { + #[allow(unsafe_code)] + pub fn handle(&self) -> HandleObject { + unsafe { self.0.handle() } + } +} + +#[derive(JSTraceable)] +pub enum ModuleError { + Network(NetworkError), + RawException(RootedTraceableBox>), +} + +impl Eq for ModuleError {} + +impl PartialEq for ModuleError { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (Self::Network(_), Self::RawException(_)) | + (Self::RawException(_), Self::Network(_)) => false, + _ => true, + } + } +} + +impl Ord for ModuleError { + fn cmp(&self, other: &Self) -> Ordering { + match (self, other) { + (Self::Network(_), Self::RawException(_)) => Ordering::Greater, + (Self::RawException(_), Self::Network(_)) => Ordering::Less, + _ => Ordering::Equal, + } + } +} + +impl PartialOrd for ModuleError { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl ModuleError { + #[allow(unsafe_code)] + pub fn handle(&self) -> Handle { + match self { + Self::Network(_) => unreachable!(), + Self::RawException(exception) => exception.handle(), + } + } +} + +impl Clone for ModuleError { + fn clone(&self) -> Self { + match self { + Self::Network(network_error) => Self::Network(network_error.clone()), + Self::RawException(exception) => Self::RawException(RootedTraceableBox::from_box( + Heap::boxed(exception.get().clone()), + )), + } + } +} + +struct ModuleScript { + base_url: ServoUrl, +} + +#[derive(JSTraceable)] +pub struct ModuleTree { + url: ServoUrl, + text: DomRefCell, + record: DomRefCell>, + status: DomRefCell, + parent_urls: DomRefCell>, + descendant_urls: DomRefCell>, + visited_urls: DomRefCell>, + error: DomRefCell>, + promise: DomRefCell>>, +} + +impl ModuleTree { + pub fn new(url: ServoUrl) -> Self { + ModuleTree { + url, + text: DomRefCell::new(DOMString::new()), + record: DomRefCell::new(None), + status: DomRefCell::new(ModuleStatus::Initial), + parent_urls: DomRefCell::new(HashSet::new()), + descendant_urls: DomRefCell::new(HashSet::new()), + visited_urls: DomRefCell::new(HashSet::new()), + error: DomRefCell::new(None), + promise: DomRefCell::new(None), + } + } + + pub fn get_promise(&self) -> &DomRefCell>> { + &self.promise + } + + pub fn set_promise(&self, promise: Rc) { + *self.promise.borrow_mut() = Some(promise); + } + + pub fn get_status(&self) -> ModuleStatus { + self.status.borrow().clone() + } + + pub fn set_status(&self, status: ModuleStatus) { + *self.status.borrow_mut() = status; + } + + pub fn get_record(&self) -> &DomRefCell> { + &self.record + } + + pub fn set_record(&self, record: ModuleObject) { + *self.record.borrow_mut() = Some(record); + } + + pub fn get_error(&self) -> &DomRefCell> { + &self.error + } + + pub fn set_error(&self, error: Option) { + *self.error.borrow_mut() = error; + } + + pub fn get_text(&self) -> &DomRefCell { + &self.text + } + + pub fn set_text(&self, module_text: DOMString) { + *self.text.borrow_mut() = module_text; + } + + pub fn get_parent_urls(&self) -> &DomRefCell> { + &self.parent_urls + } + + pub fn insert_parent_url(&self, parent_url: ServoUrl) { + self.parent_urls.borrow_mut().insert(parent_url); + } + + pub fn append_parent_urls(&self, parent_urls: HashSet) { + self.parent_urls.borrow_mut().extend(parent_urls); + } + + pub fn get_descendant_urls(&self) -> &DomRefCell> { + &self.descendant_urls + } + + pub fn append_descendant_urls(&self, descendant_urls: HashSet) { + self.descendant_urls.borrow_mut().extend(descendant_urls); + } + + /// recursively checks if all of the transitive descendants are + /// in the FetchingDescendants or later status + fn recursive_check_descendants( + module_tree: &ModuleTree, + module_map: &HashMap>, + discovered_urls: &mut HashSet, + ) -> bool { + discovered_urls.insert(module_tree.url.clone()); + + let descendant_urls = module_tree.descendant_urls.borrow(); + + for descendant_module in descendant_urls + .iter() + .filter_map(|url| module_map.get(&url.clone())) + { + if discovered_urls.contains(&descendant_module.url) { + continue; + } + + let descendant_status = descendant_module.get_status(); + if descendant_status < ModuleStatus::FetchingDescendants { + return false; + } + + let all_ready_descendants = ModuleTree::recursive_check_descendants( + &descendant_module, + module_map, + discovered_urls, + ); + + if !all_ready_descendants { + return false; + } + } + + return true; + } + + fn has_all_ready_descendants(&self, module_map: &HashMap>) -> bool { + let mut discovered_urls = HashSet::new(); + + return ModuleTree::recursive_check_descendants(&self, module_map, &mut discovered_urls); + } + + pub fn get_visited_urls(&self) -> &DomRefCell> { + &self.visited_urls + } + + pub fn append_handler(&self, owner: ModuleOwner, module_url: ServoUrl, is_top_level: bool) { + let promise = self.promise.borrow(); + + let resolve_this = owner.clone(); + let reject_this = owner.clone(); + + let resolved_url = module_url.clone(); + let rejected_url = module_url.clone(); + + let handler = PromiseNativeHandler::new( + &owner.global(), + Some(ModuleHandler::new(Box::new( + task!(fetched_resolve: move || { + resolve_this.finish_module_load(Some(resolved_url), is_top_level); + }), + ))), + Some(ModuleHandler::new(Box::new( + task!(failure_reject: move || { + reject_this.finish_module_load(Some(rejected_url), is_top_level); + }), + ))), + ); + + let _compartment = enter_realm(&*owner.global()); + AlreadyInCompartment::assert(&*owner.global()); + let _ais = AutoIncumbentScript::new(&*owner.global()); + + let promise = promise.as_ref().unwrap(); + + promise.append_native_handler(&handler); + } +} + +#[derive(Clone, Copy, Debug, JSTraceable, PartialEq, PartialOrd)] +pub enum ModuleStatus { + Initial, + Fetching, + FetchingDescendants, + FetchFailed, + Ready, + Finished, +} + +impl ModuleTree { + #[allow(unsafe_code)] + /// https://html.spec.whatwg.org/multipage/#creating-a-module-script + /// Step 7-11. + fn compile_module_script( + &self, + global: &GlobalScope, + module_script_text: DOMString, + url: ServoUrl, + ) -> Result { + let module: Vec = module_script_text.encode_utf16().collect(); + + let url_cstr = ffi::CString::new(url.as_str().as_bytes()).unwrap(); + + let _ac = JSAutoRealm::new(*global.get_cx(), *global.reflector().get_jsobject()); + + let compile_options = CompileOptionsWrapper::new(*global.get_cx(), url_cstr.as_ptr(), 1); + + rooted!(in(*global.get_cx()) let mut module_script = ptr::null_mut::()); + + let mut source = get_source_text(&module); + + unsafe { + if !CompileModule( + *global.get_cx(), + compile_options.ptr, + &mut source, + &mut module_script.handle_mut(), + ) { + warn!("fail to compile module script of {}", url); + + rooted!(in(*global.get_cx()) let mut exception = UndefinedValue()); + assert!(JS_GetPendingException( + *global.get_cx(), + &mut exception.handle_mut() + )); + JS_ClearPendingException(*global.get_cx()); + + return Err(ModuleError::RawException(RootedTraceableBox::from_box( + Heap::boxed(exception.get()), + ))); + } + + let module_script_data = Box::new(ModuleScript { + base_url: url.clone(), + }); + + SetModulePrivate( + module_script.get(), + &PrivateValue(Box::into_raw(module_script_data) as *const _), + ); + } + + debug!("module script of {} compile done", url); + + self.resolve_requested_module_specifiers( + &global, + module_script.handle().into_handle(), + url.clone(), + ) + .map(|_| ModuleObject(Heap::boxed(*module_script))) + } + + #[allow(unsafe_code)] + pub fn instantiate_module_tree( + &self, + global: &GlobalScope, + module_record: HandleObject, + ) -> Result<(), ModuleError> { + let _ac = JSAutoRealm::new(*global.get_cx(), *global.reflector().get_jsobject()); + + unsafe { + if !ModuleInstantiate(*global.get_cx(), module_record) { + warn!("fail to instantiate module"); + + rooted!(in(*global.get_cx()) let mut exception = UndefinedValue()); + assert!(JS_GetPendingException( + *global.get_cx(), + &mut exception.handle_mut() + )); + JS_ClearPendingException(*global.get_cx()); + + Err(ModuleError::RawException(RootedTraceableBox::from_box( + Heap::boxed(exception.get()), + ))) + } else { + debug!("module instantiated successfully"); + + Ok(()) + } + } + } + + #[allow(unsafe_code)] + pub fn execute_module( + &self, + global: &GlobalScope, + module_record: HandleObject, + ) -> Result<(), ModuleError> { + let _ac = JSAutoRealm::new(*global.get_cx(), *global.reflector().get_jsobject()); + + unsafe { + if !ModuleEvaluate(*global.get_cx(), module_record) { + warn!("fail to evaluate module"); + + rooted!(in(*global.get_cx()) let mut exception = UndefinedValue()); + assert!(JS_GetPendingException( + *global.get_cx(), + &mut exception.handle_mut() + )); + JS_ClearPendingException(*global.get_cx()); + + Err(ModuleError::RawException(RootedTraceableBox::from_box( + Heap::boxed(exception.get()), + ))) + } else { + debug!("module evaluated successfully"); + Ok(()) + } + } + } + + #[allow(unsafe_code)] + pub fn report_error(&self, global: &GlobalScope) { + let module_error = self.error.borrow(); + + if let Some(exception) = &*module_error { + unsafe { + JS_SetPendingException(*global.get_cx(), exception.handle()); + report_pending_exception(*global.get_cx(), true); + } + } + } + + /// https://html.spec.whatwg.org/multipage/#fetch-the-descendants-of-a-module-script + /// Step 5. + pub fn resolve_requested_modules( + &self, + global: &GlobalScope, + ) -> Result, ModuleError> { + let status = self.get_status(); + + assert_ne!(status, ModuleStatus::Initial); + assert_ne!(status, ModuleStatus::Fetching); + + let record = self.record.borrow(); + + if let Some(raw_record) = &*record { + let valid_specifier_urls = self.resolve_requested_module_specifiers( + &global, + raw_record.handle(), + self.url.clone(), + ); + + return valid_specifier_urls.map(|parsed_urls| { + parsed_urls + .iter() + .filter_map(|parsed_url| { + let mut visited = self.visited_urls.borrow_mut(); + + if !visited.contains(&parsed_url) { + visited.insert(parsed_url.clone()); + + Some(parsed_url.clone()) + } else { + None + } + }) + .collect::>() + }); + } + + unreachable!("Didn't have record while resolving its requested module") + } + + #[allow(unsafe_code)] + fn resolve_requested_module_specifiers( + &self, + global: &GlobalScope, + module_object: HandleObject, + base_url: ServoUrl, + ) -> Result, ModuleError> { + let _ac = JSAutoRealm::new(*global.get_cx(), *global.reflector().get_jsobject()); + + let mut specifier_urls = HashSet::new(); + + unsafe { + rooted!(in(*global.get_cx()) let requested_modules = GetRequestedModules(*global.get_cx(), module_object)); + + let mut length = 0; + + if !JS_GetArrayLength(*global.get_cx(), requested_modules.handle(), &mut length) { + let module_length_error = + gen_type_error(&global, "Wrong length of requested modules".to_owned()); + + return Err(module_length_error); + } + + for index in 0..length { + rooted!(in(*global.get_cx()) let mut element = UndefinedValue()); + + if !JS_GetElement( + *global.get_cx(), + requested_modules.handle(), + index, + &mut element.handle_mut(), + ) { + let get_element_error = + gen_type_error(&global, "Failed to get requested module".to_owned()); + + return Err(get_element_error); + } + + rooted!(in(*global.get_cx()) let specifier = GetRequestedModuleSpecifier( + *global.get_cx(), element.handle() + )); + + let url = ModuleTree::resolve_module_specifier( + *global.get_cx(), + &base_url, + specifier.handle().into_handle(), + ); + + if url.is_err() { + let specifier_error = + gen_type_error(&global, "Wrong module specifier".to_owned()); + + return Err(specifier_error); + } + + specifier_urls.insert(url.unwrap()); + } + } + + Ok(specifier_urls) + } + + /// The following module specifiers are allowed by the spec: + /// - a valid absolute URL + /// - a valid relative URL that starts with "/", "./" or "../" + /// + /// Bareword module specifiers are currently disallowed as these may be given + /// special meanings in the future. + /// https://html.spec.whatwg.org/multipage/#resolve-a-module-specifier + #[allow(unsafe_code)] + fn resolve_module_specifier( + cx: *mut JSContext, + url: &ServoUrl, + specifier: RawHandle<*mut JSString>, + ) -> Result { + let specifier_str = unsafe { jsstring_to_str(cx, *specifier) }; + + // Step 1. + if let Ok(specifier_url) = ServoUrl::parse(&specifier_str) { + return Ok(specifier_url); + } + + // Step 2. + if !specifier_str.starts_with("/") && + !specifier_str.starts_with("./") && + !specifier_str.starts_with("../") + { + return Err(UrlParseError::InvalidDomainCharacter); + } + + // Step 3. + return ServoUrl::parse_with_base(Some(url), &specifier_str.clone()); + } + + /// https://html.spec.whatwg.org/multipage/#finding-the-first-parse-error + fn find_first_parse_error( + global: &GlobalScope, + module_tree: &ModuleTree, + discovered_urls: &mut HashSet, + ) -> Option { + // 3. + discovered_urls.insert(module_tree.url.clone()); + + // 4. + let module_map = global.get_module_map().borrow(); + let record = module_tree.get_record().borrow(); + if record.is_none() { + let module_error = module_tree.get_error().borrow(); + + return module_error.clone(); + } + + // 5-6. + let descendant_urls = module_tree.get_descendant_urls().borrow(); + + for descendant_module in descendant_urls + .iter() + // 7. + .filter_map(|url| module_map.get(&url.clone())) + { + // 8-2. + if discovered_urls.contains(&descendant_module.url) { + continue; + } + + // 8-3. + let child_parse_error = + ModuleTree::find_first_parse_error(&global, &descendant_module, discovered_urls); + + // 8-4. + if child_parse_error.is_some() { + return child_parse_error; + } + } + + // Step 9. + return None; + } +} + +#[derive(JSTraceable, MallocSizeOf)] +struct ModuleHandler { + #[ignore_malloc_size_of = "Measuring trait objects is hard"] + task: DomRefCell>>, +} + +impl ModuleHandler { + pub fn new(task: Box) -> Box { + Box::new(Self { + task: DomRefCell::new(Some(task)), + }) + } +} + +impl Callback for ModuleHandler { + fn callback(&self, _cx: *mut JSContext, _v: HandleValue) { + let task = self.task.borrow_mut().take().unwrap(); + task.run_box(); + } +} + +/// The owner of the module +/// It can be `worker` or `script` element +#[derive(Clone)] +pub enum ModuleOwner { + #[allow(dead_code)] + Worker(TrustedWorkerAddress), + Window(Trusted), +} + +impl ModuleOwner { + pub fn global(&self) -> DomRoot { + match &self { + ModuleOwner::Worker(worker) => (*worker.root().clone()).global(), + ModuleOwner::Window(script) => (*script.root()).global(), + } + } + + fn gen_promise_with_final_handler( + &self, + module_url: Option, + is_top_level: bool, + ) -> Rc { + let resolve_this = self.clone(); + let reject_this = self.clone(); + + let resolved_url = module_url.clone(); + let rejected_url = module_url.clone(); + + let handler = PromiseNativeHandler::new( + &self.global(), + Some(ModuleHandler::new(Box::new( + task!(fetched_resolve: move || { + resolve_this.finish_module_load(resolved_url, is_top_level); + }), + ))), + Some(ModuleHandler::new(Box::new( + task!(failure_reject: move || { + reject_this.finish_module_load(rejected_url, is_top_level); + }), + ))), + ); + + let compartment = enter_realm(&*self.global()); + let comp = InCompartment::Entered(&compartment); + let _ais = AutoIncumbentScript::new(&*self.global()); + + let promise = Promise::new_in_current_compartment(&self.global(), comp); + + promise.append_native_handler(&handler); + + promise + } + + /// https://html.spec.whatwg.org/multipage/#fetch-the-descendants-of-and-link-a-module-script + /// step 4-7. + pub fn finish_module_load(&self, module_url: Option, is_top_level: bool) { + match &self { + ModuleOwner::Worker(_) => unimplemented!(), + ModuleOwner::Window(script) => { + let global = self.global(); + + let document = document_from_node(&*script.root()); + + let module_map = global.get_module_map().borrow(); + + let (module_tree, mut load) = if let Some(script_src) = module_url.clone() { + let module_tree = module_map.get(&script_src.clone()).unwrap().clone(); + + let load = Ok(ScriptOrigin::external( + module_tree.get_text().borrow().clone(), + script_src.clone(), + ScriptType::Module, + )); + + debug!( + "Going to finish external script from {}", + script_src.clone() + ); + + (module_tree, load) + } else { + let module_tree = { + let inline_module_map = global.get_inline_module_map().borrow(); + inline_module_map + .get(&script.root().get_script_id()) + .unwrap() + .clone() + }; + + let base_url = document.base_url(); + + let load = Ok(ScriptOrigin::internal( + module_tree.get_text().borrow().clone(), + base_url.clone(), + ScriptType::Module, + )); + + debug!("Going to finish internal script from {}", base_url.clone()); + + (module_tree, load) + }; + + module_tree.set_status(ModuleStatus::Finished); + + if !module_tree.has_all_ready_descendants(&module_map) { + return; + } + + let parent_urls = module_tree.get_parent_urls().borrow(); + let parent_all_ready = parent_urls + .iter() + .filter_map(|parent_url| module_map.get(&parent_url.clone())) + .all(|parent_tree| parent_tree.has_all_ready_descendants(&module_map)); + + if !parent_all_ready { + return; + } + + parent_urls + .iter() + .filter_map(|parent_url| module_map.get(&parent_url.clone())) + .for_each(|parent_tree| { + let parent_promise = parent_tree.get_promise().borrow(); + if let Some(promise) = parent_promise.as_ref() { + promise.resolve_native(&()); + } + }); + + let mut discovered_urls: HashSet = HashSet::new(); + let module_error = + ModuleTree::find_first_parse_error(&global, &module_tree, &mut discovered_urls); + + match module_error { + None => { + let module_record = module_tree.get_record().borrow(); + if let Some(record) = &*module_record { + let instantiated = + module_tree.instantiate_module_tree(&global, record.handle()); + + if let Err(exception) = instantiated { + module_tree.set_error(Some(exception.clone())); + } + } + }, + Some(ModuleError::RawException(exception)) => { + module_tree.set_error(Some(ModuleError::RawException(exception))); + }, + Some(ModuleError::Network(network_error)) => { + module_tree.set_error(Some(ModuleError::Network(network_error.clone()))); + + // Change the `result` load of the script into `network` error + load = Err(network_error); + }, + }; + + if is_top_level { + let r#async = script + .root() + .upcast::() + .has_attribute(&local_name!("async")); + + if !r#async && (&*script.root()).get_parser_inserted() { + document.deferred_script_loaded(&*script.root(), load); + } else if !r#async && !(&*script.root()).get_non_blocking() { + document.asap_in_order_script_loaded(&*script.root(), load); + } else { + document.asap_script_loaded(&*script.root(), load); + }; + } + }, + } + } +} + +/// The context required for asynchronously loading an external module script source. +struct ModuleContext { + /// The owner of the module that initiated the request. + owner: ModuleOwner, + /// The response body received to date. + data: Vec, + /// The response metadata received to date. + metadata: Option, + /// The initial URL requested. + url: ServoUrl, + /// Destination of current module context + destination: Destination, + /// Indicates whether the request failed, and why + status: Result<(), NetworkError>, + /// Timing object for this resource + resource_timing: ResourceFetchTiming, +} + +impl FetchResponseListener for ModuleContext { + fn process_request_body(&mut self) {} // TODO(cybai): Perhaps add custom steps to perform fetch here? + + fn process_request_eof(&mut self) {} // TODO(cybai): Perhaps add custom steps to perform fetch here? + + fn process_response(&mut self, metadata: Result) { + self.metadata = metadata.ok().map(|meta| match meta { + FetchMetadata::Unfiltered(m) => m, + FetchMetadata::Filtered { unsafe_, .. } => unsafe_, + }); + + let status_code = self + .metadata + .as_ref() + .and_then(|m| match m.status { + Some((c, _)) => Some(c), + _ => None, + }) + .unwrap_or(0); + + self.status = match status_code { + 0 => Err(NetworkError::Internal( + "No http status code received".to_owned(), + )), + 200..=299 => Ok(()), // HTTP ok status codes + _ => Err(NetworkError::Internal(format!( + "HTTP error code {}", + status_code + ))), + }; + } + + fn process_response_chunk(&mut self, mut chunk: Vec) { + if self.status.is_ok() { + self.data.append(&mut chunk); + } + } + + /// + /// Step 9-12 + #[allow(unsafe_code)] + fn process_response_eof(&mut self, response: Result) { + let global = self.owner.global(); + + if let Some(window) = global.downcast::() { + window + .Document() + .finish_load(LoadType::Script(self.url.clone())); + } + + // Step 9-1 & 9-2. + let load = response.and(self.status.clone()).and_then(|_| { + // Step 9-3. + let meta = self.metadata.take().unwrap(); + + if let Some(content_type) = meta.content_type.map(Serde::into_inner) { + if !SCRIPT_JS_MIMES.contains(&content_type.to_string().as_str()) { + return Err(NetworkError::Internal("Invalid MIME type".to_owned())); + } + } + + // Step 10. + let (source_text, _, _) = UTF_8.decode(&self.data); + Ok(ScriptOrigin::external( + DOMString::from(source_text), + meta.final_url, + ScriptType::Module, + )) + }); + + if let Err(err) = load { + // Step 9. + warn!("Failed to fetch {}", self.url.clone()); + let module_tree = { + let module_map = global.get_module_map().borrow(); + module_map.get(&self.url.clone()).unwrap().clone() + }; + + module_tree.set_status(ModuleStatus::FetchFailed); + + module_tree.set_error(Some(ModuleError::Network(err))); + + let promise = module_tree.get_promise().borrow(); + promise.as_ref().unwrap().resolve_native(&()); + + return; + } + + // Step 12. + if let Ok(ref resp_mod_script) = load { + let module_tree = { + let module_map = global.get_module_map().borrow(); + module_map.get(&self.url.clone()).unwrap().clone() + }; + + module_tree.set_text(resp_mod_script.text()); + + let compiled_module = module_tree.compile_module_script( + &global, + resp_mod_script.text(), + self.url.clone(), + ); + + match compiled_module { + Err(exception) => { + module_tree.set_error(Some(exception)); + + let promise = module_tree.get_promise().borrow(); + promise.as_ref().unwrap().resolve_native(&()); + + return; + }, + Ok(record) => { + module_tree.set_record(record); + + { + let mut visited = module_tree.get_visited_urls().borrow_mut(); + visited.insert(self.url.clone()); + } + + let descendant_results = fetch_module_descendants_and_link( + &self.owner, + &module_tree, + self.destination.clone(), + ); + + // Resolve the request of this module tree promise directly + // when there's no descendant + if descendant_results.is_none() { + module_tree.set_status(ModuleStatus::Ready); + + let promise = module_tree.get_promise().borrow(); + promise.as_ref().unwrap().resolve_native(&()); + } + }, + } + } + } + + fn resource_timing_mut(&mut self) -> &mut ResourceFetchTiming { + &mut self.resource_timing + } + + fn resource_timing(&self) -> &ResourceFetchTiming { + &self.resource_timing + } + + fn submit_resource_timing(&mut self) { + network_listener::submit_timing(self) + } +} + +impl ResourceTimingListener for ModuleContext { + fn resource_timing_information(&self) -> (InitiatorType, ServoUrl) { + let initiator_type = InitiatorType::LocalName("module".to_string()); + (initiator_type, self.url.clone()) + } + + fn resource_timing_global(&self) -> DomRoot { + self.owner.global() + } +} + +impl PreInvoke for ModuleContext {} + +#[allow(unsafe_code)] +/// A function to register module hooks (e.g. listening on resolving modules, +/// getting module metadata, getting script private reference and resolving dynamic import) +pub unsafe fn EnsureModuleHooksInitialized(rt: *mut JSRuntime) { + if GetModuleResolveHook(rt).is_some() { + return; + } + + SetModuleResolveHook(rt, Some(HostResolveImportedModule)); + SetModuleMetadataHook(rt, None); + SetScriptPrivateReferenceHooks(rt, None, None); + + SetModuleDynamicImportHook(rt, None); +} + +#[allow(unsafe_code)] +/// https://tc39.github.io/ecma262/#sec-hostresolveimportedmodule +/// https://html.spec.whatwg.org/multipage/#hostresolveimportedmodule(referencingscriptormodule%2C-specifier) +unsafe extern "C" fn HostResolveImportedModule( + cx: *mut JSContext, + reference_private: RawHandleValue, + specifier: RawHandle<*mut JSString>, +) -> *mut JSObject { + let global_scope = GlobalScope::from_context(cx); + + // Step 2. + let mut base_url = global_scope.api_base_url(); + + // Step 3. + let module_data = (reference_private.to_private() as *const ModuleScript).as_ref(); + if let Some(data) = module_data { + base_url = data.base_url.clone(); + } + + // Step 5. + let url = ModuleTree::resolve_module_specifier(*global_scope.get_cx(), &base_url, specifier); + + // Step 6. + assert!(url.is_ok()); + + let parsed_url = url.unwrap(); + + // Step 4 & 7. + let module_map = global_scope.get_module_map().borrow(); + + let module_tree = module_map.get(&parsed_url); + + // Step 9. + assert!(module_tree.is_some()); + + let fetched_module_object = module_tree.unwrap().get_record().borrow(); + + // Step 8. + assert!(fetched_module_object.is_some()); + + // Step 10. + if let Some(record) = &*fetched_module_object { + return record.handle().get(); + } + + unreachable!() +} + +/// https://html.spec.whatwg.org/multipage/#fetch-a-module-script-tree +pub fn fetch_external_module_script( + owner: ModuleOwner, + url: ServoUrl, + destination: Destination, +) -> Rc { + // Step 1. + fetch_single_module_script( + owner, + url, + destination, + Referrer::Client, + ParserMetadata::NotParserInserted, + None, + true, + ) +} + +/// https://html.spec.whatwg.org/multipage/#fetch-a-single-module-script +pub fn fetch_single_module_script( + owner: ModuleOwner, + url: ServoUrl, + destination: Destination, + referrer: Referrer, + parser_metadata: ParserMetadata, + parent_url: Option, + top_level_module_fetch: bool, +) -> Rc { + { + // Step 1. + let global = owner.global(); + let module_map = global.get_module_map().borrow(); + + debug!("Start to fetch {}", url.clone()); + + if let Some(module_tree) = module_map.get(&url.clone()) { + let status = module_tree.get_status(); + + let promise = module_tree.get_promise().borrow(); + + debug!( + "Meet a fetched url {} and its status is {:?}", + url.clone(), + status + ); + + assert!(promise.is_some()); + + module_tree.append_handler(owner.clone(), url.clone(), top_level_module_fetch); + + let promise = promise.as_ref().unwrap(); + + match status { + ModuleStatus::Initial => unreachable!( + "We have the module in module map so its status should not be `initial`" + ), + // Step 2. + ModuleStatus::Fetching => return promise.clone(), + ModuleStatus::FetchingDescendants => { + if module_tree.has_all_ready_descendants(&module_map) { + let module_error = module_tree.get_error().borrow(); + + if module_error.is_some() { + promise.resolve_native(&()); + } else { + promise.resolve_native(&()); + } + } + }, + // Step 3. + ModuleStatus::FetchFailed | ModuleStatus::Ready | ModuleStatus::Finished => { + let module_error = module_tree.get_error().borrow(); + + if module_error.is_some() { + promise.resolve_native(&()); + } else { + promise.resolve_native(&()); + } + }, + } + + return promise.clone(); + } + } + + let global = owner.global(); + + let module_tree = ModuleTree::new(url.clone()); + module_tree.set_status(ModuleStatus::Fetching); + + let promise = owner.gen_promise_with_final_handler(Some(url.clone()), top_level_module_fetch); + + module_tree.set_promise(promise.clone()); + if let Some(parent_url) = parent_url { + module_tree.insert_parent_url(parent_url); + } + + // Step 4. + global.set_module_map(url.clone(), module_tree); + + // Step 5-6. + let mode = match destination.clone() { + Destination::Worker | Destination::SharedWorker if top_level_module_fetch => { + RequestMode::SameOrigin + }, + _ => RequestMode::CorsMode, + }; + + let document: Option> = match &owner { + ModuleOwner::Worker(_) => None, + ModuleOwner::Window(script) => Some(document_from_node(&*script.root())), + }; + + // Step 7-8. + let request = RequestBuilder::new(url.clone()) + .destination(destination.clone()) + .origin(global.origin().immutable().clone()) + .referrer(Some(referrer)) + .parser_metadata(parser_metadata) + .mode(mode); + + let context = Arc::new(Mutex::new(ModuleContext { + owner, + data: vec![], + metadata: None, + url: url.clone(), + destination: destination.clone(), + status: Ok(()), + resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource), + })); + + let (action_sender, action_receiver) = ipc::channel().unwrap(); + + let listener = NetworkListener { + context, + task_source: global.networking_task_source(), + canceller: Some(global.task_canceller(TaskSourceName::Networking)), + }; + + ROUTER.add_route( + action_receiver.to_opaque(), + Box::new(move |message| { + listener.notify_fetch(message.to().unwrap()); + }), + ); + + if let Some(doc) = document { + doc.fetch_async(LoadType::Script(url), request, action_sender); + } + + promise +} + +#[allow(unsafe_code)] +/// https://html.spec.whatwg.org/multipage/#fetch-an-inline-module-script-graph +pub fn fetch_inline_module_script( + owner: ModuleOwner, + module_script_text: DOMString, + url: ServoUrl, + script_id: ScriptId, +) { + let global = owner.global(); + + let module_tree = ModuleTree::new(url.clone()); + + let promise = owner.gen_promise_with_final_handler(None, true); + + module_tree.set_promise(promise.clone()); + + let compiled_module = + module_tree.compile_module_script(&global, module_script_text, url.clone()); + + match compiled_module { + Ok(record) => { + module_tree.set_record(record); + + let descendant_results = + fetch_module_descendants_and_link(&owner, &module_tree, Destination::Script); + + global.set_inline_module_map(script_id, module_tree); + + if descendant_results.is_none() { + promise.resolve_native(&()); + } + }, + Err(exception) => { + module_tree.set_status(ModuleStatus::Ready); + module_tree.set_error(Some(exception)); + global.set_inline_module_map(script_id, module_tree); + promise.resolve_native(&()); + }, + } +} + +/// https://html.spec.whatwg.org/multipage/#fetch-the-descendants-of-and-link-a-module-script +/// Step 1-3. +#[allow(unsafe_code)] +fn fetch_module_descendants_and_link( + owner: &ModuleOwner, + module_tree: &ModuleTree, + destination: Destination, +) -> Option> { + let descendant_results = fetch_module_descendants(owner, module_tree, destination); + + match descendant_results { + Ok(descendants) => { + if descendants.len() > 0 { + unsafe { + let global = owner.global(); + + let _compartment = enter_realm(&*global); + AlreadyInCompartment::assert(&*global); + let _ais = AutoIncumbentScript::new(&*global); + + let abv = CreateAutoObjectVector(*global.get_cx()); + + for descendant in descendants { + assert!(AppendToAutoObjectVector( + abv as *mut AutoObjectVector, + descendant.promise_obj().get() + )); + } + + rooted!(in(*global.get_cx()) let raw_promise_all = GetWaitForAllPromise(*global.get_cx(), abv)); + + let promise_all = + Promise::new_with_js_promise(raw_promise_all.handle(), global.get_cx()); + + let promise = module_tree.get_promise().borrow(); + let promise = promise.as_ref().unwrap().clone(); + + let resolve_promise = TrustedPromise::new(promise.clone()); + let reject_promise = TrustedPromise::new(promise.clone()); + + let handler = PromiseNativeHandler::new( + &global, + Some(ModuleHandler::new(Box::new( + task!(all_fetched_resolve: move || { + let promise = resolve_promise.root(); + promise.resolve_native(&()); + }), + ))), + Some(ModuleHandler::new(Box::new( + task!(all_failure_reject: move || { + let promise = reject_promise.root(); + promise.reject_native(&()); + }), + ))), + ); + + promise_all.append_native_handler(&handler); + + return Some(promise_all); + } + } + }, + Err(err) => { + module_tree.set_error(Some(err)); + }, + } + + None +} + +#[allow(unsafe_code)] +/// https://html.spec.whatwg.org/multipage/#fetch-the-descendants-of-a-module-script +fn fetch_module_descendants( + owner: &ModuleOwner, + module_tree: &ModuleTree, + destination: Destination, +) -> Result>, ModuleError> { + debug!("Start to load dependencies of {}", module_tree.url.clone()); + + let global = owner.global(); + + module_tree.set_status(ModuleStatus::FetchingDescendants); + + module_tree + .resolve_requested_modules(&global) + .map(|requested_urls| { + module_tree.append_descendant_urls(requested_urls.clone()); + + let parent_urls = module_tree.get_parent_urls().borrow(); + + if parent_urls.intersection(&requested_urls).count() > 0 { + return Vec::new(); + } + + requested_urls + .iter() + .map(|requested_url| { + // https://html.spec.whatwg.org/multipage/#internal-module-script-graph-fetching-procedure + // Step 1. + { + let visited = module_tree.get_visited_urls().borrow(); + assert!(visited.get(&requested_url).is_some()); + } + + // Step 2. + fetch_single_module_script( + owner.clone(), + requested_url.clone(), + destination.clone(), + Referrer::Client, + ParserMetadata::NotParserInserted, + Some(module_tree.url.clone()), + false, + ) + }) + .collect() + }) +} diff --git a/components/script/script_runtime.rs b/components/script/script_runtime.rs index 3f82e3496e66..284c49312c6d 100644 --- a/components/script/script_runtime.rs +++ b/components/script/script_runtime.rs @@ -30,6 +30,7 @@ use crate::dom::promise::Promise; use crate::dom::promiserejectionevent::PromiseRejectionEvent; use crate::dom::response::Response; use crate::microtask::{EnqueuedPromiseCallback, Microtask, MicrotaskQueue}; +use crate::script_module::EnsureModuleHooksInitialized; use crate::script_thread::trace_thread; use crate::task::TaskBox; use crate::task_source::networking::NetworkingTaskSource; @@ -498,6 +499,8 @@ unsafe fn new_rt_and_cx_with_parent( SetJobQueue(cx, job_queue); SetPromiseRejectionTrackerCallback(cx, Some(promise_rejection_tracker), ptr::null_mut()); + EnsureModuleHooksInitialized(runtime.rt()); + set_gc_zeal_options(cx); // Enable or disable the JITs. From cfad32cffdaa86c1ff2f57bb25c3947202f75e94 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Thu, 12 Dec 2019 00:48:14 +0900 Subject: [PATCH 03/11] Support `integrity` for module script --- components/script/dom/htmlscriptelement.rs | 1 + components/script/script_module.rs | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs index b594660a8350..66e70da48e81 100644 --- a/components/script/dom/htmlscriptelement.rs +++ b/components/script/dom/htmlscriptelement.rs @@ -582,6 +582,7 @@ impl HTMLScriptElement { ModuleOwner::Window(Trusted::new(self)), url.clone(), Destination::Script, + integrity_metadata.to_owned(), ); if !r#async && was_parser_inserted { diff --git a/components/script/script_module.rs b/components/script/script_module.rs index 9a1c297aac07..14331f5ce61a 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -1095,6 +1095,7 @@ pub fn fetch_external_module_script( owner: ModuleOwner, url: ServoUrl, destination: Destination, + integrity_metadata: String, ) -> Rc { // Step 1. fetch_single_module_script( @@ -1103,6 +1104,7 @@ pub fn fetch_external_module_script( destination, Referrer::Client, ParserMetadata::NotParserInserted, + integrity_metadata, None, true, ) @@ -1115,6 +1117,7 @@ pub fn fetch_single_module_script( destination: Destination, referrer: Referrer, parser_metadata: ParserMetadata, + integrity_metadata: String, parent_url: Option, top_level_module_fetch: bool, ) -> Rc { @@ -1209,6 +1212,7 @@ pub fn fetch_single_module_script( .origin(global.origin().immutable().clone()) .referrer(Some(referrer)) .parser_metadata(parser_metadata) + .integrity_metadata(integrity_metadata.clone()) .mode(mode); let context = Arc::new(Mutex::new(ModuleContext { @@ -1395,6 +1399,7 @@ fn fetch_module_descendants( destination.clone(), Referrer::Client, ParserMetadata::NotParserInserted, + "".to_owned(), Some(module_tree.url.clone()), false, ) From 5c9536acdc8aed056fa91e0e3cffd3e3e0b0ad03 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Mon, 16 Dec 2019 10:25:33 +0900 Subject: [PATCH 04/11] Support module script credentials mode --- components/script/dom/htmlscriptelement.rs | 17 ++++++++++++-- components/script/script_module.rs | 26 ++++++++++++++++++---- 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs index 66e70da48e81..8285b26605d5 100644 --- a/components/script/dom/htmlscriptelement.rs +++ b/components/script/dom/htmlscriptelement.rs @@ -38,7 +38,7 @@ use ipc_channel::ipc; use ipc_channel::router::ROUTER; use js::jsval::UndefinedValue; use msg::constellation_msg::PipelineId; -use net_traits::request::{CorsSettings, Destination, Referrer, RequestBuilder}; +use net_traits::request::{CorsSettings, CredentialsMode, Destination, Referrer, RequestBuilder}; use net_traits::ReferrerPolicy; use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError}; use net_traits::{ResourceFetchTiming, ResourceTimingType}; @@ -491,7 +491,18 @@ impl HTMLScriptElement { // Step 16. let cors_setting = cors_setting_for_element(element); - // TODO: Step 17: Module script credentials mode. + // Step 17. + let credentials_mode = match script_type { + ScriptType::Classic => None, + ScriptType::Module => Some(reflect_cross_origin_attribute(element).map_or( + CredentialsMode::CredentialsSameOrigin, + |attr| match &*attr { + "use-credentials" => CredentialsMode::Include, + "anonymous" => CredentialsMode::CredentialsSameOrigin, + _ => CredentialsMode::CredentialsSameOrigin, + }, + )), + }; // TODO: Step 18: Nonce. @@ -583,6 +594,7 @@ impl HTMLScriptElement { url.clone(), Destination::Script, integrity_metadata.to_owned(), + credentials_mode.unwrap(), ); if !r#async && was_parser_inserted { @@ -637,6 +649,7 @@ impl HTMLScriptElement { text.clone(), base_url.clone(), self.id.clone(), + credentials_mode.unwrap(), ); }, } diff --git a/components/script/script_module.rs b/components/script/script_module.rs index 14331f5ce61a..9bff3fb237e1 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -55,7 +55,8 @@ use js::rust::wrappers::JS_SetPendingException; use js::rust::CompileOptionsWrapper; use js::rust::IntoHandle; use js::rust::{Handle, HandleValue}; -use net_traits::request::{Destination, ParserMetadata, Referrer, RequestBuilder, RequestMode}; +use net_traits::request::{CredentialsMode, Destination, ParserMetadata}; +use net_traits::request::{Referrer, RequestBuilder, RequestMode}; use net_traits::{FetchMetadata, Metadata}; use net_traits::{FetchResponseListener, NetworkError}; use net_traits::{ResourceFetchTiming, ResourceTimingType}; @@ -856,6 +857,8 @@ struct ModuleContext { url: ServoUrl, /// Destination of current module context destination: Destination, + /// Credentials Mode of current module context + credentials_mode: CredentialsMode, /// Indicates whether the request failed, and why status: Result<(), NetworkError>, /// Timing object for this resource @@ -986,6 +989,7 @@ impl FetchResponseListener for ModuleContext { &self.owner, &module_tree, self.destination.clone(), + self.credentials_mode.clone(), ); // Resolve the request of this module tree promise directly @@ -1096,6 +1100,7 @@ pub fn fetch_external_module_script( url: ServoUrl, destination: Destination, integrity_metadata: String, + credentials_mode: CredentialsMode, ) -> Rc { // Step 1. fetch_single_module_script( @@ -1105,6 +1110,7 @@ pub fn fetch_external_module_script( Referrer::Client, ParserMetadata::NotParserInserted, integrity_metadata, + credentials_mode, None, true, ) @@ -1118,6 +1124,7 @@ pub fn fetch_single_module_script( referrer: Referrer, parser_metadata: ParserMetadata, integrity_metadata: String, + credentials_mode: CredentialsMode, parent_url: Option, top_level_module_fetch: bool, ) -> Rc { @@ -1213,6 +1220,7 @@ pub fn fetch_single_module_script( .referrer(Some(referrer)) .parser_metadata(parser_metadata) .integrity_metadata(integrity_metadata.clone()) + .credentials_mode(credentials_mode) .mode(mode); let context = Arc::new(Mutex::new(ModuleContext { @@ -1221,6 +1229,7 @@ pub fn fetch_single_module_script( metadata: None, url: url.clone(), destination: destination.clone(), + credentials_mode: credentials_mode.clone(), status: Ok(()), resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource), })); @@ -1254,6 +1263,7 @@ pub fn fetch_inline_module_script( module_script_text: DOMString, url: ServoUrl, script_id: ScriptId, + credentials_mode: CredentialsMode, ) { let global = owner.global(); @@ -1270,8 +1280,12 @@ pub fn fetch_inline_module_script( Ok(record) => { module_tree.set_record(record); - let descendant_results = - fetch_module_descendants_and_link(&owner, &module_tree, Destination::Script); + let descendant_results = fetch_module_descendants_and_link( + &owner, + &module_tree, + Destination::Script, + credentials_mode, + ); global.set_inline_module_map(script_id, module_tree); @@ -1295,8 +1309,10 @@ fn fetch_module_descendants_and_link( owner: &ModuleOwner, module_tree: &ModuleTree, destination: Destination, + credentials_mode: CredentialsMode, ) -> Option> { - let descendant_results = fetch_module_descendants(owner, module_tree, destination); + let descendant_results = + fetch_module_descendants(owner, module_tree, destination, credentials_mode); match descendant_results { Ok(descendants) => { @@ -1364,6 +1380,7 @@ fn fetch_module_descendants( owner: &ModuleOwner, module_tree: &ModuleTree, destination: Destination, + credentials_mode: CredentialsMode, ) -> Result>, ModuleError> { debug!("Start to load dependencies of {}", module_tree.url.clone()); @@ -1400,6 +1417,7 @@ fn fetch_module_descendants( Referrer::Client, ParserMetadata::NotParserInserted, "".to_owned(), + credentials_mode.clone(), Some(module_tree.url.clone()), false, ) From 1cc6435cfcf8ae2234fd7343491f3d943fdf4eeb Mon Sep 17 00:00:00 2001 From: CYBAI Date: Fri, 29 Nov 2019 12:21:55 +0900 Subject: [PATCH 05/11] Implement nomodule attribute --- components/script/dom/htmlscriptelement.rs | 10 +++++++++- components/script/dom/webidls/HTMLScriptElement.webidl | 2 ++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs index 8285b26605d5..3a55590c81d3 100644 --- a/components/script/dom/htmlscriptelement.rs +++ b/components/script/dom/htmlscriptelement.rs @@ -447,7 +447,10 @@ impl HTMLScriptElement { return; } - // TODO: Step 12: nomodule content attribute + // Step 12 + if element.has_attribute(&local_name!("nomodule")) && script_type == ScriptType::Classic { + return; + } // Step 13. if !element.has_attribute(&local_name!("src")) && @@ -1062,6 +1065,11 @@ impl HTMLScriptElementMethods for HTMLScriptElement { // https://html.spec.whatwg.org/multipage/#dom-script-defer make_bool_setter!(SetDefer, "defer"); + // https://html.spec.whatwg.org/multipage/#dom-script-nomodule + make_bool_getter!(NoModule, "nomodule"); + // https://html.spec.whatwg.org/multipage/#dom-script-nomodule + make_bool_setter!(SetNoModule, "nomodule"); + // https://html.spec.whatwg.org/multipage/#dom-script-integrity make_getter!(Integrity, "integrity"); // https://html.spec.whatwg.org/multipage/#dom-script-integrity diff --git a/components/script/dom/webidls/HTMLScriptElement.webidl b/components/script/dom/webidls/HTMLScriptElement.webidl index f7126b7901b0..13b69865fa52 100644 --- a/components/script/dom/webidls/HTMLScriptElement.webidl +++ b/components/script/dom/webidls/HTMLScriptElement.webidl @@ -11,6 +11,8 @@ interface HTMLScriptElement : HTMLElement { attribute USVString src; [CEReactions] attribute DOMString type; + [CEReactions] + attribute boolean noModule; [CEReactions] attribute DOMString charset; [CEReactions] From e7bc0fae4c438fc548ecaf616b6a20b093eaba1c Mon Sep 17 00:00:00 2001 From: CYBAI Date: Sat, 19 Oct 2019 00:31:43 +0900 Subject: [PATCH 06/11] Update test expectation --- .../getComputedStyle-insets-absolute.html.ini | 973 +++++++++++++++++- .../getComputedStyle-insets-fixed.html.ini | 973 +++++++++++++++++- .../getComputedStyle-insets-nobox.html.ini | 2 - .../getComputedStyle-insets-relative.html.ini | 757 +++++++++++++- .../getComputedStyle-insets-static.html.ini | 2 - ...nsets-sticky-container-for-abspos.html.ini | 757 +++++++++++++- .../getComputedStyle-insets-sticky.html.ini | 757 +++++++++++++- .../html/dom/idlharness.https.html.ini | 6 - .../html/dom/reflection-misc.html.ini | 114 -- .../css-module/utf8.tentative.html.ini | 9 +- .../module/charset-01.html.ini | 3 - .../module/charset-02.html.ini | 8 +- .../module/charset-03.html.ini | 3 - .../module/choice-of-error-1.html.ini | 4 - .../module/choice-of-error-2.html.ini | 4 - .../module/choice-of-error-3.html.ini | 4 - .../module/compilation-error-1.html.ini | 5 - .../module/compilation-error-2.html.ini | 5 - .../module/credentials.sub.html.ini | 1 + .../module/crossorigin.html.ini | 32 - .../module/currentScript-null.html.ini | 3 - .../module/custom-element-exception.html.ini | 5 - .../module/duplicated-imports-1.html.ini | 2 - .../module/duplicated-imports-2.html.ini | 2 - .../module/error-and-slow-dependency.html.ini | 3 - .../module/error-type-1.html.ini | 4 - .../module/error-type-2.html.ini | 4 - .../module/error-type-3.html.ini | 4 - .../module/errorhandling.html.ini | 18 - .../module/evaluation-error-1.html.ini | 5 - .../module/evaluation-error-2.html.ini | 5 - .../module/evaluation-error-3.html.ini | 5 - .../module/evaluation-error-4.html.ini | 5 - .../module/execorder.html.ini | 21 - .../module/fetch-error-1.html.ini | 5 - .../module/fetch-error-2.html.ini | 5 - .../module/import-subgraph-404.html.ini | 3 - .../module/imports.html.ini | 15 - .../module/inactive-context-import.html.ini | 5 + .../module/inline-async-execorder.html.ini | 4 - .../module/instantiation-error-1.html.ini | 8 - .../module/instantiation-error-2.html.ini | 8 - .../module/instantiation-error-3.html.ini | 8 - .../module/instantiation-error-4.html.ini | 8 - .../module/instantiation-error-5.html.ini | 8 - .../module/instantiation-error-6.html.ini | 5 - .../module/instantiation-error-7.html.ini | 5 - .../module/instantiation-error-8.html.ini | 6 - .../module/integrity.html.ini | 3 - .../module/late-namespace-request.html.ini | 5 - .../module/late-star-export-request.html.ini | 5 - .../module/load-error-events-inline.html.ini | 26 +- .../module/load-error-events.html.ini | 27 - .../module/module-in-xhtml.xhtml.ini | 5 - .../module/module-vs-script-1.html.ini | 5 - .../module/module-vs-script-2.html.ini | 5 - .../module/nomodule-attribute.html.ini | 5 - .../module/referrer-no-referrer.sub.html.ini | 2 - ...rrer-origin-when-cross-origin.sub.html.ini | 19 +- .../module/referrer-origin.sub.html.ini | 19 +- .../module/referrer-same-origin.sub.html.ini | 10 +- .../module/referrer-unsafe-url.sub.html.ini | 19 +- .../module/script-for-event.html.ini | 3 - .../module/single-evaluation-1.html.ini | 5 - .../module/single-evaluation-2.html.ini | 5 - .../module/slow-cycle.html.ini | 3 - .../module/specifier-error.html.ini | 5 - .../nomodule-reflect.html.ini | 32 - ...odule-set-on-async-classic-script.html.ini | 8 - ...ule-set-on-external-module-script.html.ini | 5 - ...ule-set-on-inline-classic-scripts.html.ini | 8 - ...odule-set-on-inline-module-script.html.ini | 5 - ...chronously-loaded-classic-scripts.html.ini | 5 - 73 files changed, 4293 insertions(+), 544 deletions(-) delete mode 100644 tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini delete mode 100644 tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini create mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini delete mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini index 0fcea9e70f72..7459d90358ed 100644 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini +++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini @@ -1,2 +1,973 @@ [getComputedStyle-insets-absolute.html] - expected: TIMEOUT + [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini index e46b9c445e00..dd428b03af05 100644 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini +++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini @@ -1,2 +1,973 @@ [getComputedStyle-insets-fixed.html] - expected: TIMEOUT + [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini deleted file mode 100644 index 7ca66dc04563..000000000000 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[getComputedStyle-insets-nobox.html] - expected: TIMEOUT diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini index 623f02a9f9a1..60a7cddb8e3b 100644 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini +++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini @@ -1,2 +1,757 @@ [getComputedStyle-insets-relative.html] - expected: TIMEOUT + [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini deleted file mode 100644 index 555f2b80aae5..000000000000 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[getComputedStyle-insets-static.html] - expected: TIMEOUT diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini index 41718a2bea78..ad55e43fe664 100644 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini +++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini @@ -1,2 +1,757 @@ [getComputedStyle-insets-sticky-container-for-abspos.html] - expected: TIMEOUT + [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + diff --git a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini index 4723e4371f43..a9bd906e52d9 100644 --- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini +++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini @@ -1,2 +1,757 @@ [getComputedStyle-insets-sticky.html] - expected: TIMEOUT + [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] + expected: FAIL + + [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels] + expected: FAIL + + [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is] + expected: FAIL + + [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is] + expected: FAIL + + [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels] + expected: FAIL + + [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is] + expected: FAIL + + [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] + expected: FAIL + + [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] + expected: FAIL + diff --git a/tests/wpt/metadata/html/dom/idlharness.https.html.ini b/tests/wpt/metadata/html/dom/idlharness.https.html.ini index c026f0614c06..8b979d90b2fc 100644 --- a/tests/wpt/metadata/html/dom/idlharness.https.html.ini +++ b/tests/wpt/metadata/html/dom/idlharness.https.html.ini @@ -2916,9 +2916,6 @@ [HTMLInputElement interface: createInput("text") must inherit property "valueAsNumber" with the proper type] expected: FAIL - [HTMLScriptElement interface: attribute noModule] - expected: FAIL - [HTMLInputElement interface: createInput("checkbox") must inherit property "stepDown(long)" with the proper type] expected: FAIL @@ -3828,9 +3825,6 @@ [HTMLInputElement interface: createInput("text") must inherit property "useMap" with the proper type] expected: FAIL - [HTMLScriptElement interface: document.createElement("script") must inherit property "noModule" with the proper type] - expected: FAIL - [HTMLTableSectionElement interface: document.createElement("thead") must inherit property "align" with the proper type] expected: FAIL diff --git a/tests/wpt/metadata/html/dom/reflection-misc.html.ini b/tests/wpt/metadata/html/dom/reflection-misc.html.ini index 4a991afe689e..9ff7bf5a98b7 100644 --- a/tests/wpt/metadata/html/dom/reflection-misc.html.ini +++ b/tests/wpt/metadata/html/dom/reflection-misc.html.ini @@ -17610,102 +17610,6 @@ [script.nonce: IDL set to object "test-valueOf"] expected: FAIL - [script.noModule: typeof IDL attribute] - expected: FAIL - - [script.noModule: IDL get with DOM attribute unset] - expected: FAIL - - [script.noModule: setAttribute() to ""] - expected: FAIL - - [script.noModule: setAttribute() to " foo "] - expected: FAIL - - [script.noModule: setAttribute() to undefined] - expected: FAIL - - [script.noModule: setAttribute() to null] - expected: FAIL - - [script.noModule: setAttribute() to 7] - expected: FAIL - - [script.noModule: setAttribute() to 1.5] - expected: FAIL - - [script.noModule: setAttribute() to true] - expected: FAIL - - [script.noModule: setAttribute() to false] - expected: FAIL - - [script.noModule: setAttribute() to object "[object Object\]"] - expected: FAIL - - [script.noModule: setAttribute() to NaN] - expected: FAIL - - [script.noModule: setAttribute() to Infinity] - expected: FAIL - - [script.noModule: setAttribute() to -Infinity] - expected: FAIL - - [script.noModule: setAttribute() to "\\0"] - expected: FAIL - - [script.noModule: setAttribute() to object "test-toString"] - expected: FAIL - - [script.noModule: setAttribute() to object "test-valueOf"] - expected: FAIL - - [script.noModule: setAttribute() to "noModule"] - expected: FAIL - - [script.noModule: IDL set to ""] - expected: FAIL - - [script.noModule: IDL set to " foo "] - expected: FAIL - - [script.noModule: IDL set to undefined] - expected: FAIL - - [script.noModule: IDL set to null] - expected: FAIL - - [script.noModule: IDL set to 7] - expected: FAIL - - [script.noModule: IDL set to 1.5] - expected: FAIL - - [script.noModule: IDL set to false] - expected: FAIL - - [script.noModule: IDL set to object "[object Object\]"] - expected: FAIL - - [script.noModule: IDL set to NaN] - expected: FAIL - - [script.noModule: IDL set to Infinity] - expected: FAIL - - [script.noModule: IDL set to -Infinity] - expected: FAIL - - [script.noModule: IDL set to "\\0"] - expected: FAIL - - [script.noModule: IDL set to object "test-toString"] - expected: FAIL - - [script.noModule: IDL set to object "test-valueOf"] - expected: FAIL - [menu.type: setAttribute() to "context"] expected: FAIL @@ -19212,9 +19116,6 @@ [undefinedelement.tabIndex: setAttribute() to "5%"] expected: FAIL - [script.noModule: setAttribute() to "5%"] - expected: FAIL - [undefinedelement.dir: setAttribute() to "5%"] expected: FAIL @@ -19416,9 +19317,6 @@ [details.dir: setAttribute() to "5%"] expected: FAIL - [script.noModule: IDL set to "5%"] - expected: FAIL - [summary.dir: IDL set to "5%"] expected: FAIL @@ -19440,9 +19338,6 @@ [script.accessKey: IDL set to "+100"] expected: FAIL - [script.noModule: IDL set to "+100"] - expected: FAIL - [ins.dateTime: IDL set to "+100"] expected: FAIL @@ -19581,9 +19476,6 @@ [details.tabIndex: setAttribute() to "+100"] expected: FAIL - [script.noModule: setAttribute() to "+100"] - expected: FAIL - [script.dir: setAttribute() to ".5"] expected: FAIL @@ -19611,9 +19503,6 @@ [menu.dir: IDL set to ".5"] expected: FAIL - [script.noModule: IDL set to ".5"] - expected: FAIL - [dialog.tabIndex: setAttribute() to "+100"] expected: FAIL @@ -19839,9 +19728,6 @@ [dialog.dir: IDL set to "+100"] expected: FAIL - [script.noModule: setAttribute() to ".5"] - expected: FAIL - [undefinedelement.enterKeyHint: setAttribute() to "+100"] expected: FAIL diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini index 8ee01faecbd9..0ea72a3bf482 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini @@ -1,14 +1,13 @@ [utf8.tentative.html] - expected: TIMEOUT [windows-1252] - expected: NOTRUN + expected: FAIL [utf-7] - expected: NOTRUN + expected: FAIL [shift-jis] - expected: NOTRUN + expected: FAIL [utf-8] - expected: NOTRUN + expected: FAIL diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini deleted file mode 100644 index d958b30d7f49..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[charset-01.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini index a919b698590d..08b105f35072 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini @@ -1,3 +1,7 @@ [charset-02.html] - type: testharness - expected: TIMEOUT + [UTF-16 module script with UTF-16LE BOM] + expected: FAIL + + [UTF-16 module script with UTF-16BE BOM] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini deleted file mode 100644 index 16b431784060..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[charset-03.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini deleted file mode 100644 index 2046faa6ed8d..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[choice-of-error-1.html] - [Parse errors in different files should be reported depending on different roots] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini deleted file mode 100644 index 9d55b00ff314..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[choice-of-error-2.html] - [Instantiation errors in different files should be reported depending on different roots] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini deleted file mode 100644 index 19e185bb343b..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[choice-of-error-3.html] - [Evaluation errors are cached in intermediate module scripts] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini deleted file mode 100644 index 689887b78e17..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[compilation-error-1.html] - type: testharness - [Test that syntax errors lead to SyntaxError events on window, and that exceptions are remembered.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini deleted file mode 100644 index 5d518d97d25d..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[compilation-error-2.html] - type: testharness - [Test that syntax errors lead to SyntaxError events on window, and that exceptions are remembered.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini index 2e41efe9ac74..1d6ade5a09dc 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini @@ -1,3 +1,4 @@ + [credentials.sub.html] type: testharness [Modules should be loaded with or without the credentials based on the same-origin-ness and the crossOrigin attribute] diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini deleted file mode 100644 index 20738173875f..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini +++ /dev/null @@ -1,32 +0,0 @@ -[crossorigin.html] - type: testharness - [Root module, Error in CORS-different-origin script] - expected: FAIL - - [Root module, Error in CORS-same-origin script] - expected: FAIL - - [Root module, Blocked script download, missing CORS ACAO header] - expected: FAIL - - [Root module, Blocked script download, mismatched CORS ACAO header] - expected: FAIL - - [Imported module, Error in CORS-different-origin script] - expected: FAIL - - [Imported module, Error in CORS-same-origin script] - expected: FAIL - - [Imported module, Blocked script download, missing CORS ACAO header] - expected: FAIL - - [Imported module, Blocked script download, mismatched CORS ACAO header] - expected: FAIL - - [Root module, Blocked script download, crossorigin attribute with missing CORS ACAO header] - expected: FAIL - - [Imported module, Blocked script download, crossorigin attribute with missing CORS ACAO header] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini deleted file mode 100644 index b3d97af5ba79..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[currentScript-null.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini deleted file mode 100644 index 4a87a4b2bba7..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[custom-element-exception.html] - type: testharness - [Test that exceptions from the constructor of a custom element inside a module are propagated as expected.\n] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini deleted file mode 100644 index 53623ca1a01b..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[duplicated-imports-1.html] - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini deleted file mode 100644 index 39e00fd52ce9..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[duplicated-imports-2.html] - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini deleted file mode 100644 index 6af93a6e94e2..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[error-and-slow-dependency.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini deleted file mode 100644 index c756960b09d2..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[error-type-1.html] - [network error has higher priority than parse error] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini deleted file mode 100644 index e24139fb1a2c..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[error-type-2.html] - [parse error has higher priority than instantiation error] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini deleted file mode 100644 index 58cc436ec053..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[error-type-3.html] - [instantiation error has higher priority than evaluation error] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini deleted file mode 100644 index 6d3d5fdd67cb..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini +++ /dev/null @@ -1,18 +0,0 @@ -[errorhandling.html] - type: testharness - expected: TIMEOUT - [IFrame test: 'iframe_parseError_Root'] - expected: FAIL - - [IFrame test: 'iframe_parseError_Dependent'] - expected: FAIL - - [IFrame test: 'iframe_parseError_DependentMultiple'] - expected: FAIL - - [External root module with non-script mimetype] - expected: NOTRUN - - [Module with imported non-script mimetype] - expected: NOTRUN - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini deleted file mode 100644 index 35ee19e1418a..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[evaluation-error-1.html] - type: testharness - [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini deleted file mode 100644 index f71474208e5c..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[evaluation-error-2.html] - type: testharness - [Test that ill-founded cyclic dependencies cause ReferenceError during evaluation, which leads to error events on window, and that exceptions are remembered.\n] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini deleted file mode 100644 index c2cb5cd04424..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[evaluation-error-3.html] - type: testharness - [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini deleted file mode 100644 index 16e2ac184630..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[evaluation-error-4.html] - type: testharness - [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini deleted file mode 100644 index 6df8f6cb577d..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini +++ /dev/null @@ -1,21 +0,0 @@ -[execorder.html] - type: testharness - expected: TIMEOUT - [Unordered module script execution (parsed, unordered #1)] - expected: NOTRUN - - [Unordered module script execution (parsed, unordered #2)] - expected: NOTRUN - - [Unordered module script execution (dynamic, unordered #1)] - expected: NOTRUN - - [Unordered module script execution (dynamic, unordered #2)] - expected: NOTRUN - - [Interlaced module/non-module script execution (parsed, async-ordered)] - expected: FAIL - - [Interlaced module/non-module script execution (dynamic, async-ordered)] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini deleted file mode 100644 index 7ad54e37be7a..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[fetch-error-1.html] - type: testharness - [Test that failure to fetch root leads to error event on script.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini deleted file mode 100644 index e6acfd3210b6..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[fetch-error-2.html] - type: testharness - [Test that failure to fetch dependency leads to error event on script.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini deleted file mode 100644 index c9bcdffbd0db..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[import-subgraph-404.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini deleted file mode 100644 index 8ca41f2b813a..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini +++ /dev/null @@ -1,15 +0,0 @@ -[imports.html] - type: testharness - expected: TIMEOUT - [Import a module that tries to import itself] - expected: NOTRUN - - [Import a module with a cyclical module dependency] - expected: NOTRUN - - [Import a module that validly imports itself] - expected: NOTRUN - - [Import a module with a valid cyclical module dependency] - expected: NOTRUN - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini new file mode 100644 index 000000000000..354ea7cb7c89 --- /dev/null +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini @@ -0,0 +1,5 @@ +[inactive-context-import.html] + type: testharness + [dynamic import from inactive context should not crash] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini deleted file mode 100644 index 54dcc064e7e4..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini +++ /dev/null @@ -1,4 +0,0 @@ -[inline-async-execorder.html] - [Inline async module script execution order] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini deleted file mode 100644 index b3fdd6f764e2..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[instantiation-error-1.html] - type: testharness - [Test that missing exports lead to SyntaxError events on window and load events on script, and that exceptions are remembered] - expected: FAIL - - [Test that missing exports lead to SyntaxError events on window and load events on script] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini deleted file mode 100644 index c5e6fec931aa..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[instantiation-error-2.html] - type: testharness - [Test that missing exports lead to SyntaxError events on window and load events on script, and that exceptions are remembered] - expected: FAIL - - [Test that missing exports lead to SyntaxError events on window and load events on script] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini deleted file mode 100644 index 25019f2ce0fc..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[instantiation-error-3.html] - type: testharness - [Test that unresolvable cycles lead to SyntaxError events on window and load events on script, and that exceptions are remembered] - expected: FAIL - - [Test that unresolvable cycles lead to SyntaxError events on window and load events on script] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini deleted file mode 100644 index 8acedfbc7464..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[instantiation-error-4.html] - type: testharness - [Test that loading a graph in which a module is already errored results in that module's error.] - expected: FAIL - - [Test that loading a graph in which a module is already errored results in an error.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini deleted file mode 100644 index 44be8de50915..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[instantiation-error-5.html] - type: testharness - [Test that loading a graph in which a module is already errored results in that module's error.] - expected: FAIL - - [Test that loading a graph in which a module is already errored results an error.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini deleted file mode 100644 index c1729535a19c..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[instantiation-error-6.html] - type: testharness - [Test that ambiguous star exports lead to an instantiation error and that the correct module is blamed.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini deleted file mode 100644 index 152942c50922..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[instantiation-error-7.html] - type: testharness - [Test that ambiguous star exports lead to an instantiation error, even when discovered through a star export, and that the correct module is blamed.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini deleted file mode 100644 index 693c8174ed94..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini +++ /dev/null @@ -1,6 +0,0 @@ -[instantiation-error-8.html] - type: testharness - expected: TIMEOUT - [Instantiate attempt on a tree w/ previously instantiate-failed tree as a sub-tree shouldn't crash.] - expected: TIMEOUT - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini deleted file mode 100644 index 5bcd6c0a4626..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[integrity.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini deleted file mode 100644 index 1006d488052f..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[late-namespace-request.html] - type: testharness - [Test the situation where a module is instantiated without the need for a namespace object, but later on a different module requests the namespace.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini deleted file mode 100644 index 09abe701e736..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[late-star-export-request.html] - type: testharness - [Test the situation where a module is instantiated without a use of its star-exports, but later on a different module requests them.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini index e911f6b7fb98..1753a0856d7f 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini @@ -1,27 +1,5 @@ + [load-error-events-inline.html] type: testharness - expected: TIMEOUT - [src, 200, parser-inserted, defer, no async] - expected: NOTRUN - - [src, 200, parser-inserted, no defer, async] - expected: NOTRUN - - [src, 200, not parser-inserted, no defer, no async, no non-blocking] - expected: NOTRUN - - [src, 200, not parser-inserted, no defer, async] - expected: NOTRUN - - [src, 404, parser-inserted, defer, no async] - expected: NOTRUN - - [src, 404, parser-inserted, no defer, async] - expected: NOTRUN - - [src, 404, not parser-inserted, no defer, no async, no non-blocking] - expected: NOTRUN - - [src, 404, not parser-inserted, no defer, async] - expected: NOTRUN + expected: CRASH diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini deleted file mode 100644 index b0a609048413..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini +++ /dev/null @@ -1,27 +0,0 @@ -[load-error-events.html] - type: testharness - expected: TIMEOUT - [src, 200, parser-inserted, defer, no async] - expected: NOTRUN - - [src, 200, parser-inserted, no defer, async] - expected: NOTRUN - - [src, 200, not parser-inserted, no defer, no async, no non-blocking] - expected: NOTRUN - - [src, 200, not parser-inserted, no defer, async] - expected: NOTRUN - - [src, 404, parser-inserted, defer, no async] - expected: NOTRUN - - [src, 404, parser-inserted, no defer, async] - expected: NOTRUN - - [src, 404, not parser-inserted, no defer, no async, no non-blocking] - expected: NOTRUN - - [src, 404, not parser-inserted, no defer, async] - expected: NOTRUN - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini deleted file mode 100644 index ad0ec28d7998..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini +++ /dev/null @@ -1,5 +0,0 @@ -[module-in-xhtml.xhtml] - type: testharness - [module script in XHTML documents should be evaluated.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini deleted file mode 100644 index d91d145d1dcb..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[module-vs-script-1.html] - type: testharness - [Test that evaluating something as classic script does not prevent it from being evaluated as module script.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini deleted file mode 100644 index 4864da5dc6a0..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[module-vs-script-2.html] - type: testharness - [Test that evaluating something as classic script does not prevent it from being evaluated as module script.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini deleted file mode 100644 index e595c3421fad..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[nomodule-attribute.html] - type: testharness - [Test that 'nomodule' has the desired effect on classic scripts, but no effect on module scripts.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini deleted file mode 100644 index 634cf3563188..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[referrer-no-referrer.sub.html] - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini index 92d04781a2ed..a212c8c0e930 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini @@ -1,2 +1,19 @@ [referrer-origin-when-cross-origin.sub.html] - expected: TIMEOUT + [Importing a remote-origin descendant script from a same-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + + [Importing a same-origin descendant script from a same-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + + [Importing a remote-origin descendant script from a remote-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + + [Importing a same-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + + [Importing a same-origin descendant script from a remote-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + + [Importing a remote-origin top-level script with the origin-when-cross-origin policy.] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini index 9a2db3d89932..413900f14b9f 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini @@ -1,2 +1,19 @@ [referrer-origin.sub.html] - expected: TIMEOUT + [Importing a same-origin descendant script from a same-origin top-level script with the origin policy.] + expected: FAIL + + [Importing a remote-origin descendant script from a same-origin top-level script with the origin policy.] + expected: FAIL + + [Importing a remote-origin descendant script from a remote-origin top-level script with the origin policy.] + expected: FAIL + + [Importing a same-origin descendant script from a remote-origin top-level script with the origin policy.] + expected: FAIL + + [Importing a same-origin top-level script with the origin policy.] + expected: FAIL + + [Importing a remote-origin top-level script with the origin policy.] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini index d499edb6fc87..ce528d7e6418 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini @@ -1,2 +1,10 @@ [referrer-same-origin.sub.html] - expected: TIMEOUT + [Importing a same-origin descendant script from a same-origin top-level script with the same-origin policy.] + expected: FAIL + + [Importing a same-origin descendant script from a remote-origin top-level script with the same-origin policy.] + expected: FAIL + + [Importing a same-origin top-level script with the same-origin policy.] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini index 2b700b1c9b46..c1eeb5dcec7a 100644 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini @@ -1,2 +1,19 @@ [referrer-unsafe-url.sub.html] - expected: TIMEOUT + [Importing a same-origin descendant script from a remote-origin top-level script with the unsafe-url policy.] + expected: FAIL + + [Importing a same-origin descendant script from a same-origin top-level script with the unsafe-url policy.] + expected: FAIL + + [Importing a remote-origin top-level script with the unsafe-url policy.] + expected: FAIL + + [Importing a remote-origin descendant script from a remote-origin top-level script with the unsafe-url policy.] + expected: FAIL + + [Importing a remote-origin descendant script from a same-origin top-level script with the unsafe-url policy.] + expected: FAIL + + [Importing a same-origin top-level script with the unsafe-url policy.] + expected: FAIL + diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini deleted file mode 100644 index 3ad68cd5f472..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[script-for-event.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini deleted file mode 100644 index e5b288d78e06..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[single-evaluation-1.html] - type: testharness - [Test that a module is evaluated only once, and that 'this' is undefined (because of strict mode).] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini deleted file mode 100644 index c47fc9c8a4c0..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[single-evaluation-2.html] - type: testharness - [Test that a module is evaluated only once, and that 'this' is undefined (because of strict mode).] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini deleted file mode 100644 index 37c99441cc7d..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[slow-cycle.html] - type: testharness - expected: TIMEOUT diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini deleted file mode 100644 index 44e8c1ebac68..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[specifier-error.html] - type: testharness - [Test that invalid module specifier leads to TypeError on window.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini deleted file mode 100644 index 333bbf3d0e93..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini +++ /dev/null @@ -1,32 +0,0 @@ -[nomodule-reflect.html] - type: testharness - [noModule IDL attribute on a parser created classic script element without nomodule content attribute] - expected: FAIL - - [noModule IDL attribute on a parser created classic script element with nomodule content attribute] - expected: FAIL - - [noModule IDL attribute on a parser created module script element without nomodule content attribute] - expected: FAIL - - [noModule IDL attribute on a parser created module script element with nomodule content attribute] - expected: FAIL - - [noModule IDL attribute on a dynamically created script element without nomodule content attribute] - expected: FAIL - - [noModule IDL attribute on a dynamically created script element after nomodule content attribute is set to "nomodule"] - expected: FAIL - - [noModule IDL attribute on a dynamically created script element after nomodule content attribute is set to ""] - expected: FAIL - - [noModule IDL attribute on a dynamically created script element after nomodule content attribute had been removed] - expected: FAIL - - [noModule IDL attribute must add nomodule content attribute on setting to true] - expected: FAIL - - [noModule IDL attribute must remove nomodule content attribute on setting to false] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini deleted file mode 100644 index 2a43be956390..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[nomodule-set-on-async-classic-script.html] - type: testharness - [An asynchronously loaded classic script with noModule set to true must not run] - expected: FAIL - - [An asynchronously loaded classic script with noModule set to false must run] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini deleted file mode 100644 index 926d065aecd1..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[nomodule-set-on-external-module-script.html] - type: testharness - [An external module script with nomodule content attribute must run] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini deleted file mode 100644 index cf471744a602..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini +++ /dev/null @@ -1,8 +0,0 @@ -[nomodule-set-on-inline-classic-scripts.html] - type: testharness - [An inline classic script with nomodule content attribute must not run] - expected: FAIL - - [An inline classic script element dynamically inserted after noModule was set to true must not run.] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini deleted file mode 100644 index 898f25c42175..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[nomodule-set-on-inline-module-script.html] - type: testharness - [An inline module script with nomodule content attribute must run] - expected: FAIL - diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini deleted file mode 100644 index 6bb6e4244ff3..000000000000 --- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini +++ /dev/null @@ -1,5 +0,0 @@ -[nomodule-set-on-synchronously-loaded-classic-scripts.html] - type: testharness - [A synchronously loaded external classic script with nomodule content attribute must not run] - expected: FAIL - From 9460b43f905aa5533b4650c93af8125a06f0516b Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 6 Jan 2020 11:56:27 +0530 Subject: [PATCH 07/11] Use IndexSet for storing descendants Fixes intermittent failures in `/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html` --- components/script/dom/bindings/trace.rs | 9 +++++++ components/script/script_module.rs | 34 ++++++++++++++++--------- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index 217e66837bb7..d2e1876b9d88 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -311,6 +311,15 @@ unsafe impl JSTraceable for VecDeque { } } +unsafe impl JSTraceable for indexmap::IndexSet { + #[inline] + unsafe fn trace(&self, trc: *mut JSTracer) { + for e in self.iter() { + e.trace(trc); + } + } +} + unsafe impl JSTraceable for (A, B, C, D) where A: JSTraceable, diff --git a/components/script/script_module.rs b/components/script/script_module.rs index 9bff3fb237e1..959eee193d04 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -70,6 +70,8 @@ use std::rc::Rc; use std::sync::{Arc, Mutex}; use url::ParseError as UrlParseError; +use indexmap::IndexSet; + pub fn get_source_text(source: &[u16]) -> SourceText { SourceText { units_: source.as_ptr() as *const _, @@ -162,8 +164,16 @@ pub struct ModuleTree { text: DomRefCell, record: DomRefCell>, status: DomRefCell, - parent_urls: DomRefCell>, - descendant_urls: DomRefCell>, + // The spec maintains load order for descendants, so we use an indexset for descendants and + // parents. This isn't actually necessary for parents however the IndexSet APIs don't + // interop with HashSet, and IndexSet isn't very expensive + // (https://github.com/bluss/indexmap/issues/110) + // + // By default all maps in web specs are ordered maps + // (https://infra.spec.whatwg.org/#ordered-map), however we can usually get away with using + // stdlib maps and sets because we rarely iterate over them. + parent_urls: DomRefCell>, + descendant_urls: DomRefCell>, visited_urls: DomRefCell>, error: DomRefCell>, promise: DomRefCell>>, @@ -176,8 +186,8 @@ impl ModuleTree { text: DomRefCell::new(DOMString::new()), record: DomRefCell::new(None), status: DomRefCell::new(ModuleStatus::Initial), - parent_urls: DomRefCell::new(HashSet::new()), - descendant_urls: DomRefCell::new(HashSet::new()), + parent_urls: DomRefCell::new(IndexSet::new()), + descendant_urls: DomRefCell::new(IndexSet::new()), visited_urls: DomRefCell::new(HashSet::new()), error: DomRefCell::new(None), promise: DomRefCell::new(None), @@ -224,7 +234,7 @@ impl ModuleTree { *self.text.borrow_mut() = module_text; } - pub fn get_parent_urls(&self) -> &DomRefCell> { + pub fn get_parent_urls(&self) -> &DomRefCell> { &self.parent_urls } @@ -232,15 +242,15 @@ impl ModuleTree { self.parent_urls.borrow_mut().insert(parent_url); } - pub fn append_parent_urls(&self, parent_urls: HashSet) { + pub fn append_parent_urls(&self, parent_urls: IndexSet) { self.parent_urls.borrow_mut().extend(parent_urls); } - pub fn get_descendant_urls(&self) -> &DomRefCell> { + pub fn get_descendant_urls(&self) -> &DomRefCell> { &self.descendant_urls } - pub fn append_descendant_urls(&self, descendant_urls: HashSet) { + pub fn append_descendant_urls(&self, descendant_urls: IndexSet) { self.descendant_urls.borrow_mut().extend(descendant_urls); } @@ -474,7 +484,7 @@ impl ModuleTree { pub fn resolve_requested_modules( &self, global: &GlobalScope, - ) -> Result, ModuleError> { + ) -> Result, ModuleError> { let status = self.get_status(); assert_ne!(status, ModuleStatus::Initial); @@ -503,7 +513,7 @@ impl ModuleTree { None } }) - .collect::>() + .collect::>() }); } @@ -516,10 +526,10 @@ impl ModuleTree { global: &GlobalScope, module_object: HandleObject, base_url: ServoUrl, - ) -> Result, ModuleError> { + ) -> Result, ModuleError> { let _ac = JSAutoRealm::new(*global.get_cx(), *global.reflector().get_jsobject()); - let mut specifier_urls = HashSet::new(); + let mut specifier_urls = IndexSet::new(); unsafe { rooted!(in(*global.get_cx()) let requested_modules = GetRequestedModules(*global.get_cx(), module_object)); From b8c6b55c98df105fe4a19aaa1c950f571f3afa07 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Mon, 6 Jan 2020 15:29:01 +0800 Subject: [PATCH 08/11] Remove redundant checking of promise resolve and clone of URLs --- components/script/script_module.rs | 24 ++++-------------------- 1 file changed, 4 insertions(+), 20 deletions(-) diff --git a/components/script/script_module.rs b/components/script/script_module.rs index 959eee193d04..c9352463ab3e 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -1143,18 +1143,14 @@ pub fn fetch_single_module_script( let global = owner.global(); let module_map = global.get_module_map().borrow(); - debug!("Start to fetch {}", url.clone()); + debug!("Start to fetch {}", url); if let Some(module_tree) = module_map.get(&url.clone()) { let status = module_tree.get_status(); let promise = module_tree.get_promise().borrow(); - debug!( - "Meet a fetched url {} and its status is {:?}", - url.clone(), - status - ); + debug!("Meet a fetched url {} and its status is {:?}", url, status); assert!(promise.is_some()); @@ -1170,24 +1166,12 @@ pub fn fetch_single_module_script( ModuleStatus::Fetching => return promise.clone(), ModuleStatus::FetchingDescendants => { if module_tree.has_all_ready_descendants(&module_map) { - let module_error = module_tree.get_error().borrow(); - - if module_error.is_some() { - promise.resolve_native(&()); - } else { - promise.resolve_native(&()); - } + promise.resolve_native(&()); } }, // Step 3. ModuleStatus::FetchFailed | ModuleStatus::Ready | ModuleStatus::Finished => { - let module_error = module_tree.get_error().borrow(); - - if module_error.is_some() { - promise.resolve_native(&()); - } else { - promise.resolve_native(&()); - } + promise.resolve_native(&()); }, } From 198599bd7ce95faa897926db1d0724ccbd936bf1 Mon Sep 17 00:00:00 2001 From: CYBAI Date: Mon, 6 Jan 2020 17:02:02 +0800 Subject: [PATCH 09/11] Mark error-type-1 as FAIL and fix it from #25436 --- .../the-script-element/module/error-type-1.html.ini | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini diff --git a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini new file mode 100644 index 000000000000..c756960b09d2 --- /dev/null +++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini @@ -0,0 +1,4 @@ +[error-type-1.html] + [network error has higher priority than parse error] + expected: FAIL + From be917ae9ef011a0b1ed4ea512f98a30b9d59b769 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 6 Jan 2020 13:58:47 +0530 Subject: [PATCH 10/11] Upgrade module fail warning log to error --- components/script/script_module.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/script/script_module.rs b/components/script/script_module.rs index c9352463ab3e..6a2d30d72c59 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -947,7 +947,7 @@ impl FetchResponseListener for ModuleContext { if let Err(err) = load { // Step 9. - warn!("Failed to fetch {}", self.url.clone()); + error!("Failed to fetch {} with error {:?}", self.url.clone(), err); let module_tree = { let module_map = global.get_module_map().borrow(); module_map.get(&self.url.clone()).unwrap().clone() From 508bfbd0da53b0badf76e07c6286d6bd4e29900e Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 6 Jan 2020 13:59:54 +0530 Subject: [PATCH 11/11] Fix module script MIME check to not include params Also makes it error when there is no MIME type available. --- components/script/script_module.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/components/script/script_module.rs b/components/script/script_module.rs index 6a2d30d72c59..4bb60f5a233c 100644 --- a/components/script/script_module.rs +++ b/components/script/script_module.rs @@ -931,9 +931,18 @@ impl FetchResponseListener for ModuleContext { let meta = self.metadata.take().unwrap(); if let Some(content_type) = meta.content_type.map(Serde::into_inner) { - if !SCRIPT_JS_MIMES.contains(&content_type.to_string().as_str()) { - return Err(NetworkError::Internal("Invalid MIME type".to_owned())); + let c = content_type.to_string(); + // The MIME crate includes params (e.g. charset=utf8) in the to_string + // https://github.com/hyperium/mime/issues/120 + if let Some(ty) = c.split(';').next() { + if !SCRIPT_JS_MIMES.contains(&ty) { + return Err(NetworkError::Internal(format!("Invalid MIME type: {}", ty))); + } + } else { + return Err(NetworkError::Internal("Empty MIME type".into())); } + } else { + return Err(NetworkError::Internal("No MIME type".into())); } // Step 10.