Auto merge of #29677 - mrobinson:resolved-insets, r=delan

Better implement getComputedStyle() for positioned insets

The specification dictates quite quite idiosyncratic return values when
querying insets of positioned elements via `getComputedStyle()`. These
depend on whether or not the element's size was overconstrained. This
change adds a better implementation of that in preparation for returning
proper values for `position: sticky`.

There are two changes here:
- The containing block used in `FragmentTree::find` is properly computed using the `ContainingBlockManager` data structure. This data structure is now updated during traversal through the fragment tree in `Fragment::find`.
- We now take into account whether or not a absolute elements are overconstrained when calculating their resolved insets. For absolutely positioned elements, this happens during absolute positioning. For relatively positioned elements, we can determine this when a `BoxFragment` is constructed.

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [x] There are tests for these changes

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

components/layout_2020/display_list/stacking_context.rs

@@ -5,6 +5,7 @@
 use crate::cell::ArcRefCell;
 use crate::display_list::conversions::ToWebRender;
 use crate::display_list::DisplayListBuilder;
+use crate::fragment_tree::ContainingBlockManager;
 use crate::fragments::{AnonymousFragment, BoxFragment, Fragment};
 use crate::geom::PhysicalRect;
 use crate::style_ext::ComputedValuesExt;
@@ -51,96 +52,6 @@ impl ContainingBlock {
     }
 }
 
-#[derive(Clone)]
-pub(crate) struct ContainingBlockManager<'a, T> {
-    // The containing block for all non-absolute descendants. "...if the element's
-    // position is 'relative' or 'static', the containing block is formed by the
-    // content edge of the nearest block container ancestor box." This is also
-    // the case for 'position: sticky' elements.
-    // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details
-    pub for_non_absolute_descendants: &'a T,
-
-    // The containing block for absolute descendants. "If the element has
-    // 'position: absolute', the containing block is
-    // established by the nearest ancestor with a 'position' of 'absolute',
-    // 'relative' or 'fixed', in the following way:
-    //   1. In the case that the ancestor is an inline element, the containing
-    //      block is the bounding box around the padding boxes of the first and the
-    //      last inline boxes generated for that element. In CSS 2.1, if the inline
-    //      element is split across multiple lines, the containing block is
-    //      undefined.
-    //   2. Otherwise, the containing block is formed by the padding edge of the
-    //      ancestor."
-    // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details
-    // If the ancestor forms a containing block for all descendants (see below),
-    // this value will be None and absolute descendants will use the containing
-    // block for fixed descendants.
-    pub for_absolute_descendants: Option<&'a T>,
-
-    // The containing block for fixed and absolute descendants.
-    // "For elements whose layout is governed by the CSS box model, any value
-    // other than none for the transform property also causes the element to
-    // establish a containing block for all descendants. Its padding box will be
-    // used to layout for all of its absolute-position descendants,
-    // fixed-position descendants, and descendant fixed background attachments."
-    // https://w3c.github.io/csswg-drafts/css-transforms-1/#containing-block-for-all-descendants
-    // See `ComputedValues::establishes_containing_block_for_all_descendants`
-    // for a list of conditions where an element forms a containing block for
-    // all descendants.
-    pub for_absolute_and_fixed_descendants: &'a T,
-}
-
-impl<'a, T> ContainingBlockManager<'a, T> {
-    fn get_containing_block_for_fragment(&self, fragment: &Fragment) -> &T {
-        if let Fragment::Box(box_fragment) = fragment {
-            match box_fragment.style.clone_position() {
-                ComputedPosition::Fixed => self.for_absolute_and_fixed_descendants,
-                ComputedPosition::Absolute => self
-                    .for_absolute_descendants
-                    .unwrap_or(self.for_absolute_and_fixed_descendants),
-                _ => self.for_non_absolute_descendants,
-            }
-        } else {
-            self.for_non_absolute_descendants
-        }
-    }
-
-    pub(crate) fn new_for_non_absolute_descendants(
-        &self,
-        for_non_absolute_descendants: &'a T,
-    ) -> Self {
-        return ContainingBlockManager {
-            for_non_absolute_descendants,
-            for_absolute_descendants: self.for_absolute_descendants,
-            for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants,
-        };
-    }
-
-    pub(crate) fn new_for_absolute_descendants(
-        &self,
-        for_non_absolute_descendants: &'a T,
-        for_absolute_descendants: &'a T,
-    ) -> Self {
-        return ContainingBlockManager {
-            for_non_absolute_descendants,
-            for_absolute_descendants: Some(for_absolute_descendants),
-            for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants,
-        };
-    }
-
-    pub(crate) fn new_for_absolute_and_fixed_descendants(
-        &self,
-        for_non_absolute_descendants: &'a T,
-        for_absolute_and_fixed_descendants: &'a T,
-    ) -> Self {
-        return ContainingBlockManager {
-            for_non_absolute_descendants,
-            for_absolute_descendants: None,
-            for_absolute_and_fixed_descendants,
-        };
-    }
-}
-
 pub(crate) type ContainingBlockInfo<'a> = ContainingBlockManager<'a, ContainingBlock>;
 
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]

components/layout_2020/flow/root.rs

@@ -15,7 +15,7 @@ use crate::flow::float::FloatBox;
 use crate::flow::inline::InlineLevelBox;
 use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
 use crate::formatting_contexts::IndependentFormattingContext;
-use crate::fragment_tree::Tag;
+use crate::fragment_tree::{ContainingBlockManager, Tag};
 use crate::fragments::Fragment;
 use crate::geom::flow_relative::Vec2;
 use crate::geom::{PhysicalPoint, PhysicalRect, PhysicalSize};
@@ -457,11 +457,14 @@ impl FragmentTree {
         &self,
         mut process_func: impl FnMut(&Fragment, usize, &PhysicalRect<Length>) -> Option<T>,
     ) -> Option<T> {
-        self.root_fragments.iter().find_map(|child| {
+        let info = ContainingBlockManager {
-            child
+            for_non_absolute_descendants: &self.initial_containing_block,
-                .borrow()
+            for_absolute_descendants: None,
-                .find(&self.initial_containing_block, 0, &mut process_func)
+            for_absolute_and_fixed_descendants: &self.initial_containing_block,
-        })
+        };
+        self.root_fragments
+            .iter()
+            .find_map(|child| child.borrow().find(&info, 0, &mut process_func))
     }
 
     pub fn remove_nodes_in_fragment_tree_from_set(&self, set: &mut FxHashSet<AnimationSetKey>) {

components/layout_2020/fragment_tree/containing_block.rs

@@ -0,0 +1,99 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::fragments::Fragment;
+use style::computed_values::position::T as ComputedPosition;
+
+/// A data structure used to track the containing block when recursing
+/// through the Fragment tree. It tracks the three types of containing
+/// blocks (for all descendants, for absolute and fixed position
+/// descendants, and for fixed position descendants).
+pub(crate) struct ContainingBlockManager<'a, T> {
+    // The containing block for all non-absolute descendants. "...if the element's
+    // position is 'relative' or 'static', the containing block is formed by the
+    // content edge of the nearest block container ancestor box." This is also
+    // the case for 'position: sticky' elements.
+    // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details
+    pub for_non_absolute_descendants: &'a T,
+
+    // The containing block for absolute descendants. "If the element has
+    // 'position: absolute', the containing block is
+    // established by the nearest ancestor with a 'position' of 'absolute',
+    // 'relative' or 'fixed', in the following way:
+    //   1. In the case that the ancestor is an inline element, the containing
+    //      block is the bounding box around the padding boxes of the first and the
+    //      last inline boxes generated for that element. In CSS 2.1, if the inline
+    //      element is split across multiple lines, the containing block is
+    //      undefined.
+    //   2. Otherwise, the containing block is formed by the padding edge of the
+    //      ancestor."
+    // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details
+    // If the ancestor forms a containing block for all descendants (see below),
+    // this value will be None and absolute descendants will use the containing
+    // block for fixed descendants.
+    pub for_absolute_descendants: Option<&'a T>,
+
+    // The containing block for fixed and absolute descendants.
+    // "For elements whose layout is governed by the CSS box model, any value
+    // other than none for the transform property also causes the element to
+    // establish a containing block for all descendants. Its padding box will be
+    // used to layout for all of its absolute-position descendants,
+    // fixed-position descendants, and descendant fixed background attachments."
+    // https://w3c.github.io/csswg-drafts/css-transforms-1/#containing-block-for-all-descendants
+    // See `ComputedValues::establishes_containing_block_for_all_descendants`
+    // for a list of conditions where an element forms a containing block for
+    // all descendants.
+    pub for_absolute_and_fixed_descendants: &'a T,
+}
+
+impl<'a, T> ContainingBlockManager<'a, T> {
+    pub(crate) fn get_containing_block_for_fragment(&self, fragment: &Fragment) -> &T {
+        if let Fragment::Box(box_fragment) = fragment {
+            match box_fragment.style.clone_position() {
+                ComputedPosition::Fixed => self.for_absolute_and_fixed_descendants,
+                ComputedPosition::Absolute => self
+                    .for_absolute_descendants
+                    .unwrap_or(self.for_absolute_and_fixed_descendants),
+                _ => self.for_non_absolute_descendants,
+            }
+        } else {
+            self.for_non_absolute_descendants
+        }
+    }
+
+    pub(crate) fn new_for_non_absolute_descendants(
+        &self,
+        for_non_absolute_descendants: &'a T,
+    ) -> Self {
+        return ContainingBlockManager {
+            for_non_absolute_descendants,
+            for_absolute_descendants: self.for_absolute_descendants,
+            for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants,
+        };
+    }
+
+    pub(crate) fn new_for_absolute_descendants(
+        &self,
+        for_non_absolute_descendants: &'a T,
+        for_absolute_descendants: &'a T,
+    ) -> Self {
+        return ContainingBlockManager {
+            for_non_absolute_descendants,
+            for_absolute_descendants: Some(for_absolute_descendants),
+            for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants,
+        };
+    }
+
+    pub(crate) fn new_for_absolute_and_fixed_descendants(
+        &self,
+        for_non_absolute_descendants: &'a T,
+        for_absolute_and_fixed_descendants: &'a T,
+    ) -> Self {
+        return ContainingBlockManager {
+            for_non_absolute_descendants,
+            for_absolute_descendants: None,
+            for_absolute_and_fixed_descendants,
+        };
+    }
+}

components/layout_2020/fragment_tree/mod.rs

@@ -3,5 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 mod base;
+mod containing_block;
 
 pub(crate) use base::*;
+pub(crate) use containing_block::*;

components/layout_2020/fragments.rs

@@ -3,10 +3,11 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::cell::ArcRefCell;
-use crate::fragment_tree::{BaseFragment, BaseFragmentInfo, Tag};
+use crate::fragment_tree::{BaseFragment, BaseFragmentInfo, ContainingBlockManager, Tag};
 use crate::geom::flow_relative::{Rect, Sides};
-use crate::geom::{PhysicalPoint, PhysicalRect};
+use crate::geom::{PhysicalPoint, PhysicalRect, PhysicalSides, PhysicalSize};
 use crate::positioned::HoistedSharedFragment;
+use crate::style_ext::ComputedValuesExt;
 use gfx::font::FontMetrics as GfxFontMetrics;
 use gfx::text::glyph::GlyphStore;
 use gfx_traits::print_tree::PrintTree;
@@ -14,9 +15,10 @@ use msg::constellation_msg::{BrowsingContextId, PipelineId};
 use servo_arc::Arc as ServoArc;
 use std::sync::Arc;
 use style::computed_values::overflow_x::T as ComputedOverflow;
+use style::computed_values::position::T as ComputedPosition;
 use style::logical_geometry::WritingMode;
 use style::properties::ComputedValues;
-use style::values::computed::Length;
+use style::values::computed::{CSSPixelLength, Length, LengthPercentage, LengthPercentageOrAuto};
 use style::values::specified::text::TextDecorationLine;
 use style::Zero;
 use webrender_api::{FontInstanceKey, ImageKey};
@@ -59,6 +61,9 @@ pub(crate) struct BoxFragment {
 
     /// The scrollable overflow of this box fragment.
     pub scrollable_overflow_from_children: PhysicalRect<Length>,
+
+    /// Whether or not this box was overconstrained in the given dimension.
+    overconstrained: PhysicalSize<bool>,
 }
 
 #[derive(Serialize)]
@@ -207,36 +212,54 @@ impl Fragment {
 
     pub(crate) fn find<T>(
         &self,
-        containing_block: &PhysicalRect<Length>,
+        manager: &ContainingBlockManager<PhysicalRect<Length>>,
         level: usize,
         process_func: &mut impl FnMut(&Fragment, usize, &PhysicalRect<Length>) -> Option<T>,
     ) -> Option<T> {
+        let containing_block = manager.get_containing_block_for_fragment(self);
         if let Some(result) = process_func(self, level, containing_block) {
             return Some(result);
         }
 
         match self {
             Fragment::Box(fragment) => {
-                let new_containing_block = fragment
+                let content_rect = fragment
                     .content_rect
                     .to_physical(fragment.style.writing_mode, containing_block)
                     .translate(containing_block.origin.to_vector());
-                fragment.children.iter().find_map(|child| {
+                let padding_rect = fragment
-                    child
+                    .padding_rect()
-                        .borrow()
+                    .to_physical(fragment.style.writing_mode, containing_block)
-                        .find(&new_containing_block, level + 1, process_func)
+                    .translate(containing_block.origin.to_vector());
-                })
+                let new_manager = if fragment
+                    .style
+                    .establishes_containing_block_for_all_descendants()
+                {
+                    manager.new_for_absolute_and_fixed_descendants(&content_rect, &padding_rect)
+                } else if fragment
+                    .style
+                    .establishes_containing_block_for_absolute_descendants()
+                {
+                    manager.new_for_absolute_descendants(&content_rect, &padding_rect)
+                } else {
+                    manager.new_for_non_absolute_descendants(&content_rect)
+                };
+
+                fragment
+                    .children
+                    .iter()
+                    .find_map(|child| child.borrow().find(&new_manager, level + 1, process_func))
             },
             Fragment::Anonymous(fragment) => {
-                let new_containing_block = fragment
+                let content_rect = fragment
                     .rect
                     .to_physical(fragment.mode, containing_block)
                     .translate(containing_block.origin.to_vector());
-                fragment.children.iter().find_map(|child| {
+                let new_manager = manager.new_for_non_absolute_descendants(&content_rect);
-                    child
+                fragment
-                        .borrow()
+                    .children
-                        .find(&new_containing_block, level + 1, process_func)
+                    .iter()
-                })
+                    .find_map(|child| child.borrow().find(&new_manager, level + 1, process_func))
             },
             _ => None,
         }
@@ -303,6 +326,39 @@ impl BoxFragment {
         border: Sides<Length>,
         margin: Sides<Length>,
         block_margins_collapsed_with_children: CollapsedBlockMargins,
+    ) -> BoxFragment {
+        let position = style.get_box().position;
+        let insets = style.get_position();
+        let width_overconstrained = position == ComputedPosition::Relative &&
+            !insets.left.is_auto() &&
+            !insets.right.is_auto();
+        let height_overconstrained = position == ComputedPosition::Relative &&
+            !insets.left.is_auto() &&
+            !insets.bottom.is_auto();
+
+        Self::new_with_overconstrained(
+            base_fragment_info,
+            style,
+            children,
+            content_rect,
+            padding,
+            border,
+            margin,
+            block_margins_collapsed_with_children,
+            PhysicalSize::new(width_overconstrained, height_overconstrained),
+        )
+    }
+
+    pub fn new_with_overconstrained(
+        base_fragment_info: BaseFragmentInfo,
+        style: ServoArc<ComputedValues>,
+        children: Vec<Fragment>,
+        content_rect: Rect<Length>,
+        padding: Sides<Length>,
+        border: Sides<Length>,
+        margin: Sides<Length>,
+        block_margins_collapsed_with_children: CollapsedBlockMargins,
+        overconstrained: PhysicalSize<bool>,
     ) -> BoxFragment {
         // FIXME(mrobinson, bug 25564): We should be using the containing block
         // here to properly convert scrollable overflow to physical geometry.
@@ -311,6 +367,7 @@ impl BoxFragment {
             children.iter().fold(PhysicalRect::zero(), |acc, child| {
                 acc.union(&child.scrollable_overflow(&containing_block))
             });
+
         BoxFragment {
             base: base_fragment_info.into(),
             style,
@@ -324,6 +381,7 @@ impl BoxFragment {
             margin,
             block_margins_collapsed_with_children,
             scrollable_overflow_from_children,
+            overconstrained,
         }
     }
 
@@ -363,6 +421,7 @@ impl BoxFragment {
                 \nborder rect={:?}\
                 \nscrollable_overflow={:?}\
                 \noverflow={:?} / {:?}\
+                \noverconstrained={:?}
                 \nstyle={:p}",
             self.base,
             self.content_rect,
@@ -371,6 +430,7 @@ impl BoxFragment {
             self.scrollable_overflow(&PhysicalRect::zero()),
             self.style.get_box().overflow_x,
             self.style.get_box().overflow_y,
+            self.overconstrained,
             self.style,
         ));
 
@@ -414,6 +474,81 @@ impl BoxFragment {
 
         overflow
     }
+
+    pub(crate) fn calculate_resolved_insets_if_positioned(
+        &self,
+        containing_block: &PhysicalRect<CSSPixelLength>,
+    ) -> PhysicalSides<CSSPixelLength> {
+        let position = self.style.get_box().position;
+        debug_assert_ne!(
+            position,
+            ComputedPosition::Static,
+            "Should not call this method on statically positioned box."
+        );
+
+        let (cb_width, cb_height) = (containing_block.width(), containing_block.height());
+        let content_rect = self
+            .content_rect
+            .to_physical(self.style.writing_mode, &containing_block);
+
+        // "A resolved value special case property like top defined in another
+        // specification If the property applies to a positioned element and the
+        // resolved value of the display property is not none or contents, and
+        // the property is not over-constrained, then the resolved value is the
+        // used value. Otherwise the resolved value is the computed value."
+        // https://drafts.csswg.org/cssom/#resolved-values
+        let insets = self.style.get_position();
+        if position == ComputedPosition::Relative {
+            let get_resolved_axis =
+                |start: &LengthPercentageOrAuto,
+                 end: &LengthPercentageOrAuto,
+                 container_length: CSSPixelLength| {
+                    let start = start.map(|v| v.percentage_relative_to(container_length));
+                    let end = end.map(|v| v.percentage_relative_to(container_length));
+                    match (start.non_auto(), end.non_auto()) {
+                        (None, None) => (Length::zero(), Length::zero()),
+                        (None, Some(end)) => (-end, end),
+                        (Some(start), None) => (start, -start),
+                        // This is the overconstrained case, for which the resolved insets will
+                        // simply be the computed insets.
+                        (Some(start), Some(end)) => (start, end),
+                    }
+                };
+            let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width);
+            let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height);
+            return PhysicalSides::new(top, right, bottom, left);
+        }
+
+        debug_assert!(
+            position == ComputedPosition::Fixed || position == ComputedPosition::Absolute,
+            "Got unknown position."
+        );
+
+        let resolve = |value: &LengthPercentageOrAuto, container_length| {
+            value
+                .auto_is(LengthPercentage::zero)
+                .percentage_relative_to(container_length)
+        };
+
+        let (top, bottom) = if self.overconstrained.height {
+            (
+                resolve(&insets.top, cb_height),
+                resolve(&insets.bottom, cb_height),
+            )
+        } else {
+            (content_rect.origin.y, cb_height - content_rect.max_y())
+        };
+        let (left, right) = if self.overconstrained.width {
+            (
+                resolve(&insets.left, cb_width),
+                resolve(&insets.right, cb_width),
+            )
+        } else {
+            (content_rect.origin.x, cb_width - content_rect.max_x())
+        };
+
+        PhysicalSides::new(top, right, bottom, left)
+    }
 }
 
 impl TextFragment {

components/layout_2020/positioned.rs

@@ -93,6 +93,13 @@ pub(crate) enum AbsoluteBoxOffsets {
 }
 
 impl AbsoluteBoxOffsets {
+    fn both_specified(&self) -> bool {
+        match self {
+            AbsoluteBoxOffsets::Both { .. } => return true,
+            _ => return false,
+        }
+    }
+
     fn adjust_offset(&mut self, new_offset: Length) {
         match *self {
             AbsoluteBoxOffsets::StaticStart { ref mut start } => *start = new_offset,
@@ -444,32 +451,30 @@ impl HoistedAbsolutelyPositionedBox {
         };
 
         let shared_fragment = self.fragment.borrow();
-
+        let inline_axis_solver = AbsoluteAxisSolver {
-        let solve_inline_axis = |computed_size| {
+            containing_size: cbis,
-            solve_axis(
+            padding_border_sum: pbm.padding_border_sums.inline,
-                cbis,
+            computed_margin_start: pbm.margin.inline_start,
-                pbm.padding_border_sums.inline,
+            computed_margin_end: pbm.margin.inline_end,
-                pbm.margin.inline_start,
+            avoid_negative_margin_start: true,
-                pbm.margin.inline_end,
+            box_offsets: &shared_fragment.box_offsets.inline,
-                /* avoid_negative_margin_start */ true,
-                &shared_fragment.box_offsets.inline,
-                computed_size,
-            )
-        };
-        let solve_block_axis = |computed_size| {
-            solve_axis(
-                cbbs,
-                pbm.padding_border_sums.block,
-                pbm.margin.block_start,
-                pbm.margin.block_end,
-                /* avoid_negative_margin_start */ false,
-                &shared_fragment.box_offsets.block,
-                computed_size,
-            )
         };
 
-        let mut inline_axis = solve_inline_axis(computed_size.inline);
+        let block_axis_solver = AbsoluteAxisSolver {
-        let mut block_axis = solve_block_axis(computed_size.block);
+            containing_size: cbbs,
+            padding_border_sum: pbm.padding_border_sums.block,
+            computed_margin_start: pbm.margin.block_start,
+            computed_margin_end: pbm.margin.block_end,
+            avoid_negative_margin_start: false,
+            box_offsets: &shared_fragment.box_offsets.block,
+        };
+        let overconstrained = Vec2 {
+            inline: inline_axis_solver.is_overconstrained_for_size(computed_size.inline),
+            block: block_axis_solver.is_overconstrained_for_size(computed_size.block),
+        };
+
+        let mut inline_axis = inline_axis_solver.solve_for_size(computed_size.inline);
+        let mut block_axis = block_axis_solver.solve_for_size(computed_size.block);
 
         let mut positioning_context =
             PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap();
@@ -519,7 +524,8 @@ impl HoistedAbsolutelyPositionedBox {
                     // https://drafts.csswg.org/css2/#min-max-widths (step 2)
                     if let Some(max) = max_size.inline {
                         if inline_size > max {
-                            inline_axis = solve_inline_axis(LengthOrAuto::LengthPercentage(max));
+                            inline_axis = inline_axis_solver
+                                .solve_for_size(LengthOrAuto::LengthPercentage(max));
                             inline_size = inline_axis.size.auto_is(|| unreachable!());
                         }
                     }
@@ -530,8 +536,8 @@ impl HoistedAbsolutelyPositionedBox {
                     // because a non-‘auto’ computed ‘inline-size’ always becomes the used value.
                     // https://drafts.csswg.org/css2/#min-max-widths (step 3)
                     if inline_size < min_size.inline {
-                        inline_axis =
+                        inline_axis = inline_axis_solver
-                            solve_inline_axis(LengthOrAuto::LengthPercentage(min_size.inline));
+                            .solve_for_size(LengthOrAuto::LengthPercentage(min_size.inline));
                         inline_size = inline_axis.size.auto_is(|| unreachable!());
                     }
 
@@ -581,7 +587,8 @@ impl HoistedAbsolutelyPositionedBox {
                     // https://drafts.csswg.org/css2/#min-max-heights (step 2)
                     if let Some(max) = max_size.block {
                         if result.content_size.block > max {
-                            block_axis = solve_block_axis(LengthOrAuto::LengthPercentage(max));
+                            block_axis = block_axis_solver
+                                .solve_for_size(LengthOrAuto::LengthPercentage(max));
                             result = try_layout(LengthOrAuto::LengthPercentage(max));
                         }
                     }
@@ -592,8 +599,8 @@ impl HoistedAbsolutelyPositionedBox {
                     // because a non-‘auto’ computed ‘block-size’ always becomes the used value.
                     // https://drafts.csswg.org/css2/#min-max-heights (step 3)
                     if result.content_size.block < min_size.block {
-                        block_axis =
+                        block_axis = block_axis_solver
-                            solve_block_axis(LengthOrAuto::LengthPercentage(min_size.block));
+                            .solve_for_size(LengthOrAuto::LengthPercentage(min_size.block));
                         result = try_layout(LengthOrAuto::LengthPercentage(min_size.block));
                     }
 
@@ -631,7 +638,10 @@ impl HoistedAbsolutelyPositionedBox {
                 size: content_size,
             };
 
-            BoxFragment::new(
+            let physical_overconstrained =
+                overconstrained.to_physical(containing_block.style.writing_mode);
+
+            BoxFragment::new_with_overconstrained(
                 absolutely_positioned_box.context.base_fragment_info(),
                 absolutely_positioned_box.context.style().clone(),
                 fragments,
@@ -640,6 +650,7 @@ impl HoistedAbsolutelyPositionedBox {
                 pbm.border,
                 margin,
                 CollapsedBlockMargins::zero(),
+                physical_overconstrained,
             )
         };
         positioning_context.layout_collected_children(layout_context, &mut new_fragment);
@@ -661,6 +672,16 @@ struct AxisResult {
     margin_end: Length,
 }
 
+struct AbsoluteAxisSolver<'a> {
+    containing_size: Length,
+    padding_border_sum: Length,
+    computed_margin_start: LengthOrAuto,
+    computed_margin_end: LengthOrAuto,
+    avoid_negative_margin_start: bool,
+    box_offsets: &'a AbsoluteBoxOffsets,
+}
+
+impl<'a> AbsoluteAxisSolver<'a> {
     /// This unifies some of the parts in common in:
     ///
     /// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-width
@@ -672,47 +693,39 @@ struct AxisResult {
     /// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
     ///
     /// In the replaced case, `size` is never `Auto`.
-fn solve_axis(
+    fn solve_for_size(&self, computed_size: LengthOrAuto) -> AxisResult {
-    containing_size: Length,
+        match self.box_offsets {
-    padding_border_sum: Length,
-    computed_margin_start: LengthOrAuto,
-    computed_margin_end: LengthOrAuto,
-    avoid_negative_margin_start: bool,
-    box_offsets: &AbsoluteBoxOffsets,
-    computed_size: LengthOrAuto,
-) -> AxisResult {
-    match box_offsets {
             AbsoluteBoxOffsets::StaticStart { start } => AxisResult {
                 anchor: Anchor::Start(*start),
                 size: computed_size,
-            margin_start: computed_margin_start.auto_is(Length::zero),
+                margin_start: self.computed_margin_start.auto_is(Length::zero),
-            margin_end: computed_margin_end.auto_is(Length::zero),
+                margin_end: self.computed_margin_end.auto_is(Length::zero),
             },
             AbsoluteBoxOffsets::Start { start } => AxisResult {
-            anchor: Anchor::Start(start.percentage_relative_to(containing_size)),
+                anchor: Anchor::Start(start.percentage_relative_to(self.containing_size)),
                 size: computed_size,
-            margin_start: computed_margin_start.auto_is(Length::zero),
+                margin_start: self.computed_margin_start.auto_is(Length::zero),
-            margin_end: computed_margin_end.auto_is(Length::zero),
+                margin_end: self.computed_margin_end.auto_is(Length::zero),
             },
             AbsoluteBoxOffsets::End { end } => AxisResult {
-            anchor: Anchor::End(end.percentage_relative_to(containing_size)),
+                anchor: Anchor::End(end.percentage_relative_to(self.containing_size)),
                 size: computed_size,
-            margin_start: computed_margin_start.auto_is(Length::zero),
+                margin_start: self.computed_margin_start.auto_is(Length::zero),
-            margin_end: computed_margin_end.auto_is(Length::zero),
+                margin_end: self.computed_margin_end.auto_is(Length::zero),
             },
             AbsoluteBoxOffsets::Both { start, end } => {
-            let start = start.percentage_relative_to(containing_size);
+                let start = start.percentage_relative_to(self.containing_size);
-            let end = end.percentage_relative_to(containing_size);
+                let end = end.percentage_relative_to(self.containing_size);
 
                 let margin_start;
                 let margin_end;
                 let used_size;
                 if let LengthOrAuto::LengthPercentage(s) = computed_size {
                     used_size = s;
-                let margins = containing_size - start - end - padding_border_sum - s;
+                    let margins = self.containing_size - start - end - self.padding_border_sum - s;
-                match (computed_margin_start, computed_margin_end) {
+                    match (self.computed_margin_start, self.computed_margin_end) {
                         (LengthOrAuto::Auto, LengthOrAuto::Auto) => {
-                        if avoid_negative_margin_start && margins < Length::zero() {
+                            if self.avoid_negative_margin_start && margins < Length::zero() {
                                 margin_start = Length::zero();
                                 margin_end = margins;
                             } else {
@@ -737,13 +750,17 @@ fn solve_axis(
                         },
                     }
                 } else {
-                margin_start = computed_margin_start.auto_is(Length::zero);
+                    margin_start = self.computed_margin_start.auto_is(Length::zero);
-                margin_end = computed_margin_end.auto_is(Length::zero);
+                    margin_end = self.computed_margin_end.auto_is(Length::zero);
 
                     // This may be negative, but the caller will later effectively
                     // clamp it to ‘min-inline-size’ or ‘min-block-size’.
-                used_size =
+                    used_size = self.containing_size -
-                    containing_size - start - end - padding_border_sum - margin_start - margin_end
+                        start -
+                        end -
+                        self.padding_border_sum -
+                        margin_start -
+                        margin_end;
                 };
                 AxisResult {
                     anchor: Anchor::Start(start),
@@ -755,6 +772,14 @@ fn solve_axis(
         }
     }
 
+    fn is_overconstrained_for_size(&self, computed_size: LengthOrAuto) -> bool {
+        !computed_size.is_auto() &&
+            self.box_offsets.both_specified() &&
+            !self.computed_margin_start.is_auto() &&
+            !self.computed_margin_end.is_auto()
+    }
+}
+
 fn adjust_static_positions(
     absolutely_positioned_fragments: &mut [HoistedAbsolutelyPositionedBox],
     child_fragments: &[Fragment],
@@ -796,6 +821,10 @@ pub(crate) fn relative_adjustement(
     style: &ComputedValues,
     containing_block: &ContainingBlock,
 ) -> Vec2<Length> {
+    // "If the height of the containing block is not specified explicitly (i.e.,
+    // it depends on content height), and this element is not absolutely
+    // positioned, the value computes to 'auto'.""
+    // https://www.w3.org/TR/CSS2/visudet.html#the-height-property
     let cbis = containing_block.inline_size;
     let cbbs = containing_block.block_size.auto_is(Length::zero);
     let box_offsets = style

components/layout_2020/query.rs

@@ -306,7 +306,18 @@ pub fn process_resolved_style_request<'dom>(
                 _ => return None,
             };
 
-            let positioned = style.get_box().position != Position::Static;
+            if style.get_box().position != Position::Static {
+                let resolved_insets =
+                    || box_fragment.calculate_resolved_insets_if_positioned(containing_block);
+                match longhand_id {
+                    LonghandId::Top => return Some(resolved_insets().top.to_css_string()),
+                    LonghandId::Right => return Some(resolved_insets().right.to_css_string()),
+                    LonghandId::Bottom => return Some(resolved_insets().bottom.to_css_string()),
+                    LonghandId::Left => return Some(resolved_insets().left.to_css_string()),
+                    _ => {},
+                }
+            }
+
             let content_rect = box_fragment
                 .content_rect
                 .to_physical(box_fragment.style.writing_mode, &containing_block);
@@ -327,13 +338,6 @@ pub fn process_resolved_style_request<'dom>(
                 LonghandId::PaddingTop => Some(padding.top),
                 LonghandId::PaddingLeft => Some(padding.left),
                 LonghandId::PaddingRight => Some(padding.right),
-                // TODO(mrobinson): These following values are often wrong, because these are not
-                // exactly the "used value" for the positional properties. The real used values are
-                // lost by the time the Fragment tree is constructed, so we may need to record them in
-                // the tree to properly answer this query. That said, we can return an okayish value
-                // sometimes simply by using the calculated position in the containing block.
-                LonghandId::Top if positioned => Some(content_rect.origin.y),
-                LonghandId::Left if positioned => Some(content_rect.origin.x),
                 _ => None,
             }
             .map(|value| value.to_css_string())

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini

@@ -34,3 +34,39 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 2]
+    expected: FAIL
+
+  [.container > div 3]
+    expected: FAIL
+
+  [.container > div 4]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 14]
+    expected: FAIL
+
+  [.container > div 15]
+    expected: FAIL
+
+  [.container > div 16]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini

@@ -46,3 +46,27 @@
 
   [.container > div 23]
     expected: FAIL
+
+  [.container > div 4]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 16]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini

@@ -34,3 +34,39 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 2]
+    expected: FAIL
+
+  [.container > div 3]
+    expected: FAIL
+
+  [.container > div 4]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 14]
+    expected: FAIL
+
+  [.container > div 15]
+    expected: FAIL
+
+  [.container > div 16]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini

@@ -46,3 +46,27 @@
 
   [.container > div 23]
     expected: FAIL
+
+  [.container > div 4]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 16]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini

@@ -46,3 +46,27 @@
 
   [.container > div 23]
     expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 17]
+    expected: FAIL
+
+  [.container > div 20]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini

@@ -46,3 +46,27 @@
 
   [.container > div 23]
     expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 17]
+    expected: FAIL
+
+  [.container > div 20]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini

@@ -58,3 +58,27 @@
 
   [.container > div 28]
     expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL
+
+  [.container > div 26]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini

@@ -58,3 +58,27 @@
 
   [.container > div 28]
     expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL
+
+  [.container > div 26]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini

@@ -34,3 +34,39 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 1]
+    expected: FAIL
+
+  [.container > div 2]
+    expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 13]
+    expected: FAIL
+
+  [.container > div 14]
+    expected: FAIL
+
+  [.container > div 17]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini

@@ -52,3 +52,21 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini

@@ -28,3 +28,45 @@
 
   [.container > div 22]
     expected: FAIL
+
+  [.container > div 1]
+    expected: FAIL
+
+  [.container > div 2]
+    expected: FAIL
+
+  [.container > div 5]
+    expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 9]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 13]
+    expected: FAIL
+
+  [.container > div 14]
+    expected: FAIL
+
+  [.container > div 17]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 21]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini

@@ -46,3 +46,27 @@
 
   [.container > div 21]
     expected: FAIL
+
+  [.container > div 7]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 12]
+    expected: FAIL
+
+  [.container > div 19]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL
+
+  [.container > div 24]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini

@@ -52,3 +52,21 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 20]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini

@@ -52,3 +52,21 @@
 
   [.container > div 24]
     expected: FAIL
+
+  [.container > div 8]
+    expected: FAIL
+
+  [.container > div 10]
+    expected: FAIL
+
+  [.container > div 11]
+    expected: FAIL
+
+  [.container > div 20]
+    expected: FAIL
+
+  [.container > div 22]
+    expected: FAIL
+
+  [.container > div 23]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini

@@ -22,3 +22,15 @@
 
   [.rect 16]
     expected: FAIL
+
+  [.rect 1]
+    expected: FAIL
+
+  [.rect 2]
+    expected: FAIL
+
+  [.rect 3]
+    expected: FAIL
+
+  [.rect 4]
+    expected: FAIL

tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini

@@ -1,7 +1,3 @@
 [computed-style-005.html]
-  [relative_computed_left_and_right]
-    expected: FAIL
-
   [absolute_computed_left_and_right]
     expected: FAIL
-

tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini

@@ -2,75 +2,18 @@
   [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 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
-
-  [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-rl 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-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 - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
-    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
-
   [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
     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-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-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 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
-
-  [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 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
 
@@ -83,222 +26,90 @@
   [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
-
   [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value 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
-
   [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
     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 rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
     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-lr 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 ltr - If opposite sides are 'auto', they resolve to used value]
     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-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     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
 
-  [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-lr 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 vertical-lr ltr - Percentages are absolutized into pixels]
-    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
 
-  [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-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 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-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve 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
 
-  [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 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
-
-  [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
 
   [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
     expected: FAIL
 
-  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
-    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-rl rtl - calc() is 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 - 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 - Percentages absolutize the computed value 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-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
 
@@ -308,66 +119,27 @@
   [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-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 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
-
   [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
-
-  [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 vertical-lr rtl - Percentages 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
 
-  [horizontal-tb rtl inside vertical-rl ltr - calc() is 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-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
 
@@ -377,42 +149,21 @@
   [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
-
-  [vertical-lr rtl 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 ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside horizontal-tb 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-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-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
 
@@ -422,42 +173,21 @@
   [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 rtl inside vertical-lr rtl - calc() is absolutized into pixels]
-    expected: FAIL
-
   [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
     expected: FAIL
 
-  [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
-    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
 
-  [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
-
   [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
@@ -467,74 +197,20 @@
   [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
     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-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
-
-  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
-    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 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-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
-
-  [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
 
   [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
-    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-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-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini

@@ -2,75 +2,18 @@
   [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 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
-
-  [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-rl 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-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 - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
-    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
-
   [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
     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-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-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 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
-
-  [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 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
 
@@ -83,222 +26,90 @@
   [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
-
   [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value 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
-
   [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
     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 rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
     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-lr 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 ltr - If opposite sides are 'auto', they resolve to used value]
     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-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     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
 
-  [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-lr 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 vertical-lr ltr - Percentages are absolutized into pixels]
-    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
 
-  [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-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 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-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve 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
 
-  [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 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
-
-  [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
 
   [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
     expected: FAIL
 
-  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
-    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-rl rtl - calc() is 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 - 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 - Percentages absolutize the computed value 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-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
 
@@ -308,66 +119,27 @@
   [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-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 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
-
   [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
-
-  [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 vertical-lr rtl - Percentages 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
 
-  [horizontal-tb rtl inside vertical-rl ltr - calc() is 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-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
 
@@ -377,42 +149,21 @@
   [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
-
-  [vertical-lr rtl 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 ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside horizontal-tb 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-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-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
 
@@ -422,42 +173,21 @@
   [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 rtl inside vertical-lr rtl - calc() is absolutized into pixels]
-    expected: FAIL
-
   [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
     expected: FAIL
 
-  [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
-    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
 
-  [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
-
   [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
@@ -467,74 +197,20 @@
   [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
     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-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
-
-  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
-    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 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-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
-
-  [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
 
   [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
     expected: FAIL
 
-  [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
-    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-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-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini

@@ -1,432 +0,0 @@
-[getComputedStyle-insets-relative.html]
-  [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 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
-
-  [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-rl ltr 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 horizontal-tb rtl - 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 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-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 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 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 rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
-    expected: FAIL
-
-  [vertical-lr ltr 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
-
-  [vertical-lr ltr inside vertical-rl ltr - 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 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
-
-  [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
-    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 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 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-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
-    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-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
-
-  [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-lr rtl 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-lr ltr - Percentages are absolutized into pixels]
-    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-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
-
-  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve 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
-
-  [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
-
-  [horizontal-tb 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 rtl - If opposite sides are 'auto', they resolve to used value]
-    expected: FAIL
-
-  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
-    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-rl rtl - calc() is 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 - 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-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-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 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
-
-  [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
-
-  [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 vertical-lr rtl - Percentages 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 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 rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
-    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-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
-
-  [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
-
-  [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 - 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
-
-  [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
-    expected: FAIL
-
-  [vertical-lr rtl 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 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
-
-  [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 - 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-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
-    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 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-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
-
-  [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-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
-    expected: FAIL
-
-  [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve 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