Auto merge of #23545 - CYBAI:support-module-script, r=jdm,manishearth

Support type=module script element

This is still WIP but hope can be reviewed first to see if I'm on the right track. Thanks! 🙇‍♂️

- [x] Support external module script
- [x] Support internal module script
- [x] Compile cyclic modules

---
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [x] These changes fix #23370 (GitHub issue number if applicable)
- [x] There are tests for these changes

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/23545)
<!-- Reviewable:end -->

components/script/dom/bindings/trace.rs

@@ -311,6 +311,15 @@ unsafe impl<T: JSTraceable> JSTraceable for VecDeque<T> {
     }
 }
 
+unsafe impl<T: JSTraceable + Eq + Hash> JSTraceable for indexmap::IndexSet<T> {
+    #[inline]
+    unsafe fn trace(&self, trc: *mut JSTracer) {
+        for e in self.iter() {
+            e.trace(trc);
+        }
+    }
+}
+
 unsafe impl<A, B, C, D> JSTraceable for (A, B, C, D)
 where
     A: JSTraceable,

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<HashMap<DOMString, u64>>,
 
+    /// 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<HashMap<ServoUrl, Rc<ModuleTree>>>,
+
+    #[ignore_malloc_size_of = "mozjs"]
+    inline_module_map: DomRefCell<HashMap<ScriptId, Rc<ModuleTree>>>,
+
     /// For providing instructions to an optional devtools server.
     #[ignore_malloc_size_of = "channels are hard"]
     devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
@@ -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<HashMap<ServoUrl, Rc<ModuleTree>>> {
+        &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<HashMap<ScriptId, Rc<ModuleTree>>> {
+        &self.inline_module_map
+    }
+
     #[allow(unsafe_code)]
     pub fn get_cx(&self) -> SafeJSContext {
         unsafe { SafeJSContext::from_ptr(Runtime::get()) }

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;
@@ -35,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};
@@ -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
 /// <https://html.spec.whatwg.org/multipage/#javascript-mime-type>.
-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<ScriptOrigin, NetworkError>;
@@ -427,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")) &&
@@ -441,6 +464,7 @@ impl HTMLScriptElement {
         }
 
         // Step 14.
+        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) {
@@ -459,6 +483,7 @@ impl HTMLScriptElement {
                 },
                 (_, _) => (),
             }
+        }
 
         // Step 15.
         let encoding = element
@@ -469,7 +494,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.
 
@@ -514,6 +550,7 @@ impl HTMLScriptElement {
                 },
             };
 
+            // Step 24.6.
             match script_type {
                 ScriptType::Classic => {
                     // Preparation for step 26.
@@ -555,40 +592,37 @@ impl HTMLScriptElement {
                     }
                 },
                 ScriptType::Module => {
-                    warn!(
+                    fetch_external_module_script(
-                        "{} is a module script. It should be fixed after #23545 landed.",
+                        ModuleOwner::Window(Trusted::new(self)),
-                        url.clone()
+                        url.clone(),
+                        Destination::Script,
+                        integrity_metadata.to_owned(),
+                        credentials_mode.unwrap(),
                     );
-                    self.global().issue_page_warning(&format!(
+
-                        "Module scripts are not supported; {} will not be executed.",
+                    if !r#async && was_parser_inserted {
-                        url.clone()
+                        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.
+            // Step 25-2.
-            if let ScriptType::Module = script_type {
+            match script_type {
-                warn!(
+                ScriptType::Classic => {
-                    "{} 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 26.
                     if was_parser_inserted &&
                         doc.get_current_parser()
                             .map_or(false, |parser| parser.script_nesting_level() <= 1) &&
@@ -600,6 +634,28 @@ impl HTMLScriptElement {
                         // 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);
+                    };
+
+                    fetch_inline_module_script(
+                        ModuleOwner::Window(Trusted::new(self)),
+                        text.clone(),
+                        base_url.clone(),
+                        self.id.clone(),
+                        credentials_mode.unwrap(),
+                    );
+                },
+            }
         }
     }
 
@@ -656,7 +712,7 @@ impl HTMLScriptElement {
     }
 
     /// <https://html.spec.whatwg.org/multipage/#execute-the-script-block>
-    pub fn execute(&self, result: Result<ScriptOrigin, NetworkError>) {
+    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 +730,12 @@ impl HTMLScriptElement {
             Ok(script) => 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 +748,24 @@ impl HTMLScriptElement {
         let document = document_from_node(self);
         let old_script = document.GetCurrentScript();
 
-        // Step 5.a.1.
+        match script.type_ {
+            ScriptType::Classic => {
                 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());
+            },
+            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 +797,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::<GlobalScope>();
+        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 +945,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,
@@ -930,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

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));

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]

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)]

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.

tests/wpt/include.ini

@@ -116,6 +116,10 @@ skip: true
         [json-module]
           skip: true
         [module]
+          skip: false
+          [dynamic-import]
+            skip: true
+          [import-meta]
             skip: true
 [js]
   skip: false

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
+

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
+

tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini

@@ -1,2 +0,0 @@
-[getComputedStyle-insets-nobox.html]
-  expected: TIMEOUT

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
+

tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini

@@ -1,2 +0,0 @@
-[getComputedStyle-insets-static.html]
-  expected: TIMEOUT

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
+

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
+

tests/wpt/metadata/html/dom/idlharness.https.html.ini

@@ -2907,9 +2907,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
 
@@ -3798,9 +3795,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
 

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
 

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
 

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini

@@ -1,3 +0,0 @@
-[charset-01.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini

@@ -1,3 +1,7 @@
 [charset-02.html]
-  type: testharness
+  [UTF-16 module script with UTF-16LE BOM]
-  expected: TIMEOUT
+    expected: FAIL
+
+  [UTF-16 module script with UTF-16BE BOM]
+    expected: FAIL
+

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini

@@ -1,3 +0,0 @@
-[charset-03.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini

@@ -1,4 +0,0 @@
-[choice-of-error-1.html]
-  [Parse errors in different files should be reported depending on different roots]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini

@@ -1,4 +0,0 @@
-[choice-of-error-2.html]
-  [Instantiation errors in different files should be reported depending on different roots]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini

@@ -1,4 +0,0 @@
-[choice-of-error-3.html]
-  [Evaluation errors are cached in intermediate module scripts]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini

@@ -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
-

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]

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini

@@ -1,3 +0,0 @@
-[currentScript-null.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini

@@ -1,2 +0,0 @@
-[duplicated-imports-1.html]
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini

@@ -1,2 +0,0 @@
-[duplicated-imports-2.html]
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini

@@ -1,3 +0,0 @@
-[error-and-slow-dependency.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini

@@ -1,4 +0,0 @@
-[error-type-2.html]
-  [parse error has higher priority than instantiation error]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini

@@ -1,4 +0,0 @@
-[error-type-3.html]
-  [instantiation error has higher priority than evaluation error]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini

@@ -1,5 +0,0 @@
-[fetch-error-1.html]
-  type: testharness
-  [Test that failure to fetch root leads to error event on script.]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini

@@ -1,5 +0,0 @@
-[fetch-error-2.html]
-  type: testharness
-  [Test that failure to fetch dependency leads to error event on script.]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini

@@ -1,3 +0,0 @@
-[import-subgraph-404.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini

@@ -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
-

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
+

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini

@@ -1,4 +0,0 @@
-[inline-async-execorder.html]
-  [Inline async module script execution order]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini

@@ -1,3 +0,0 @@
-[integrity.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini

@@ -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
-

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
+  expected: CRASH
-  [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
 

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini

@@ -1,5 +0,0 @@
-[module-in-xhtml.xhtml]
-  type: testharness
-  [module script in XHTML documents should be evaluated.]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini

@@ -1,2 +0,0 @@
-[referrer-no-referrer.sub.html]
-  expected: TIMEOUT

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
+

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
+

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
+

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
+

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini

@@ -1,3 +0,0 @@
-[script-for-event.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini

@@ -1,3 +0,0 @@
-[slow-cycle.html]
-  type: testharness
-  expected: TIMEOUT

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini

@@ -1,5 +0,0 @@
-[specifier-error.html]
-  type: testharness
-  [Test that invalid module specifier leads to TypeError on window.]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini

@@ -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
-

tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini

@@ -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
-