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 elements size was overconstrained. This
change adds a better implementation of that in preparation for returning
proper values for position: sticky.

26 files changed, 800 insertions, 1317 deletions

diff --git a/components/layout_2020/display_list/stacking_context.rs b/components/layout_2020/display_list/stacking_context.rs
index ec61f829374..7f15a530863 100644
--- a/components/layout_2020/display_list/stacking_context.rs
+++ b/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)]
diff --git a/components/layout_2020/flow/root.rs b/components/layout_2020/flow/root.rs
index c0ca277167c..f6eae6ea478 100644
--- a/components/layout_2020/flow/root.rs
+++ b/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| {
-            child
-                .borrow()
-                .find(&self.initial_containing_block, 0, &mut process_func)
-        })
+        let info = ContainingBlockManager {
+            for_non_absolute_descendants: &self.initial_containing_block,
+            for_absolute_descendants: None,
+            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>) {
diff --git a/components/layout_2020/fragment_tree/containing_block.rs b/components/layout_2020/fragment_tree/containing_block.rs
new file mode 100644
index 00000000000..5bd02a67867
--- /dev/null
+++ b/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,
+        };
+    }
+}
diff --git a/components/layout_2020/fragment_tree/mod.rs b/components/layout_2020/fragment_tree/mod.rs
index 1d7425655cb..96f07217ac4 100644
--- a/components/layout_2020/fragment_tree/mod.rs
+++ b/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::*;
diff --git a/components/layout_2020/fragments.rs b/components/layout_2020/fragments.rs
index 53e6d93cdc1..4dbacf10182 100644
--- a/components/layout_2020/fragments.rs
+++ b/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| {
-                    child
-                        .borrow()
-                        .find(&new_containing_block, level + 1, process_func)
-                })
+                let padding_rect = fragment
+                    .padding_rect()
+                    .to_physical(fragment.style.writing_mode, containing_block)
+                    .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| {
-                    child
-                        .borrow()
-                        .find(&new_containing_block, level + 1, process_func)
-                })
+                let new_manager = manager.new_for_non_absolute_descendants(&content_rect);
+                fragment
+                    .children
+                    .iter()
+                    .find_map(|child| child.borrow().find(&new_manager, level + 1, process_func))
             },
             _ => None,
         }
@@ -304,6 +327,39 @@ impl BoxFragment {
         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.
         let containing_block = PhysicalRect::zero();
@@ -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 {
diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs
index 744086ebc93..0a7dd28e945 100644
--- a/components/layout_2020/positioned.rs
+++ b/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 {
+            containing_size: cbis,
+            padding_border_sum: pbm.padding_border_sums.inline,
+            computed_margin_start: pbm.margin.inline_start,
+            computed_margin_end: pbm.margin.inline_end,
+            avoid_negative_margin_start: true,
+            box_offsets: &shared_fragment.box_offsets.inline,
+        };
 
-        let solve_inline_axis = |computed_size| {
-            solve_axis(
-                cbis,
-                pbm.padding_border_sums.inline,
-                pbm.margin.inline_start,
-                pbm.margin.inline_end,
-                /* avoid_negative_margin_start */ true,
-                &shared_fragment.box_offsets.inline,
-                computed_size,
-            )
+        let block_axis_solver = AbsoluteAxisSolver {
+            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 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 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 = solve_inline_axis(computed_size.inline);
-        let mut block_axis = solve_block_axis(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 =
-                            solve_inline_axis(LengthOrAuto::LengthPercentage(min_size.inline));
+                        inline_axis = inline_axis_solver
+                            .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 =
-                            solve_block_axis(LengthOrAuto::LengthPercentage(min_size.block));
+                        block_axis = block_axis_solver
+                            .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,97 +672,111 @@ struct AxisResult {
     margin_end: Length,
 }
 
-/// This unifies some of the parts in common in:
-///
-/// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-width
-/// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-height
-///
-/// … and:
-///
-/// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
-/// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
-///
-/// In the replaced case, `size` is never `Auto`.
-fn solve_axis(
+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: &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_end: computed_margin_end.auto_is(Length::zero),
-        },
-        AbsoluteBoxOffsets::Start { start } => AxisResult {
-            anchor: Anchor::Start(start.percentage_relative_to(containing_size)),
-            size: computed_size,
-            margin_start: computed_margin_start.auto_is(Length::zero),
-            margin_end: computed_margin_end.auto_is(Length::zero),
-        },
-        AbsoluteBoxOffsets::End { end } => AxisResult {
-            anchor: Anchor::End(end.percentage_relative_to(containing_size)),
-            size: computed_size,
-            margin_start: computed_margin_start.auto_is(Length::zero),
-            margin_end: computed_margin_end.auto_is(Length::zero),
-        },
-        AbsoluteBoxOffsets::Both { start, end } => {
-            let start = start.percentage_relative_to(containing_size);
-            let end = end.percentage_relative_to(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;
-                match (computed_margin_start, computed_margin_end) {
-                    (LengthOrAuto::Auto, LengthOrAuto::Auto) => {
-                        if avoid_negative_margin_start && margins < Length::zero() {
-                            margin_start = Length::zero();
-                            margin_end = margins;
-                        } else {
-                            margin_start = margins / 2.;
-                            margin_end = margins / 2.;
-                        }
-                    },
-                    (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => {
-                        margin_start = margins - end;
-                        margin_end = end;
-                    },
-                    (LengthOrAuto::LengthPercentage(start), LengthOrAuto::Auto) => {
-                        margin_start = start;
-                        margin_end = margins - start;
-                    },
-                    (
-                        LengthOrAuto::LengthPercentage(start),
-                        LengthOrAuto::LengthPercentage(end),
-                    ) => {
-                        margin_start = start;
-                        margin_end = end;
-                    },
+    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
+    /// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-height
+    ///
+    /// … and:
+    ///
+    /// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
+    /// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
+    ///
+    /// In the replaced case, `size` is never `Auto`.
+    fn solve_for_size(&self, computed_size: LengthOrAuto) -> AxisResult {
+        match self.box_offsets {
+            AbsoluteBoxOffsets::StaticStart { start } => AxisResult {
+                anchor: Anchor::Start(*start),
+                size: computed_size,
+                margin_start: self.computed_margin_start.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(self.containing_size)),
+                size: computed_size,
+                margin_start: self.computed_margin_start.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(self.containing_size)),
+                size: computed_size,
+                margin_start: self.computed_margin_start.auto_is(Length::zero),
+                margin_end: self.computed_margin_end.auto_is(Length::zero),
+            },
+            AbsoluteBoxOffsets::Both { start, end } => {
+                let start = start.percentage_relative_to(self.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 = self.containing_size - start - end - self.padding_border_sum - s;
+                    match (self.computed_margin_start, self.computed_margin_end) {
+                        (LengthOrAuto::Auto, LengthOrAuto::Auto) => {
+                            if self.avoid_negative_margin_start && margins < Length::zero() {
+                                margin_start = Length::zero();
+                                margin_end = margins;
+                            } else {
+                                margin_start = margins / 2.;
+                                margin_end = margins / 2.;
+                            }
+                        },
+                        (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => {
+                            margin_start = margins - end;
+                            margin_end = end;
+                        },
+                        (LengthOrAuto::LengthPercentage(start), LengthOrAuto::Auto) => {
+                            margin_start = start;
+                            margin_end = margins - start;
+                        },
+                        (
+                            LengthOrAuto::LengthPercentage(start),
+                            LengthOrAuto::LengthPercentage(end),
+                        ) => {
+                            margin_start = start;
+                            margin_end = end;
+                        },
+                    }
+                } else {
+                    margin_start = self.computed_margin_start.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 = self.containing_size -
+                        start -
+                        end -
+                        self.padding_border_sum -
+                        margin_start -
+                        margin_end;
+                };
+                AxisResult {
+                    anchor: Anchor::Start(start),
+                    size: LengthOrAuto::LengthPercentage(used_size),
+                    margin_start,
+                    margin_end,
                 }
-            } else {
-                margin_start = computed_margin_start.auto_is(Length::zero);
-                margin_end = 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 =
-                    containing_size - start - end - padding_border_sum - margin_start - margin_end
-            };
-            AxisResult {
-                anchor: Anchor::Start(start),
-                size: LengthOrAuto::LengthPercentage(used_size),
-                margin_start,
-                margin_end,
-            }
-        },
+    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()
     }
 }
 
@@ -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
diff --git a/components/layout_2020/query.rs b/components/layout_2020/query.rs
index 769bb9641d8..74420ae2bb5 100644
--- a/components/layout_2020/query.rs
+++ b/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())
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini
index 9f15e63c8d9..251c8f6c5f5 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini
index 6de34f368f1..00a3689c467 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini
index f23bdda21e3..bff7f467a85 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini
index 4f09d72fc23..33a95e61976 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini
index 0fcdd177ed0..cbb682aa9ca 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini
index 1e0f35df40f..20e9970b2b5 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini
index 5e9407d901d..f1042ded7b6 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini
index 23d4519fbcc..40572dbccfc 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini
index a8b41b96e70..7bdf31edac6 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini
index 04e162cafaf..325cd7b8c33 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini
index 46ba3268235..25e32718ee3 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini
index 0c925cc8c38..42a8cdeaff2 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini
index 5e0efe959a6..0dbbe7112d3 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini
index cf325fab510..0d4a746af2f 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini
index 1d51f307e09..514a578845e 100644
--- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini
index eb59a9cdab5..1da4114a01c 100644
--- a/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini
+++ b/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
-
diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini
index 7b5b8af0734..4831f60d4bd 100644
--- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini
index 6accdda38d8..9498584170e 100644
--- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini
+++ b/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
diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini
deleted file mode 100644
index 5fbcc1e89ee..00000000000
--- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini
+++ /dev/null
@@ -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