Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Better implement getComputedStyle() for positioned insets

Browse source 
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.
This commit is contained in:
Martin Robinson 2023-04-28 17:17:43 +02:00
parent 4e37d07ea4
commit e167526618
26 changed files with 801 additions and 1318 deletions
Download patch file Download diff file Expand all files Collapse all files

91
components/layout_2020/display_list/stacking_context.rs
View file

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

15
components/layout_2020/flow/root.rs
View file

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

99
components/layout_2020/fragment_tree/containing_block.rs Normal file
View file

@ -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,
};
}
}

2
components/layout_2020/fragment_tree/mod.rs
View file

@ -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::*;

167
components/layout_2020/fragments.rs
View file

@ -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,
}
@ -303,6 +326,39 @@ impl BoxFragment {
border: Sides<Length>,
margin: Sides<Length>,
block_margins_collapsed_with_children: CollapsedBlockMargins,
) -> BoxFragment {
let position = style.get_box().position;
let insets = style.get_position();
let width_overconstrained = position == ComputedPosition::Relative &&
!insets.left.is_auto() &&
!insets.right.is_auto();
let height_overconstrained = position == ComputedPosition::Relative &&
!insets.left.is_auto() &&
!insets.bottom.is_auto();
Self::new_with_overconstrained(
base_fragment_info,
style,
children,
content_rect,
padding,
border,
margin,
block_margins_collapsed_with_children,
PhysicalSize::new(width_overconstrained, height_overconstrained),
)
}
pub fn new_with_overconstrained(
base_fragment_info: BaseFragmentInfo,
style: ServoArc<ComputedValues>,
children: Vec<Fragment>,
content_rect: Rect<Length>,
padding: Sides<Length>,
border: Sides<Length>,
margin: Sides<Length>,
block_margins_collapsed_with_children: CollapsedBlockMargins,
overconstrained: PhysicalSize<bool>,
) -> BoxFragment {
// FIXME(mrobinson, bug 25564): We should be using the containing block
// here to properly convert scrollable overflow to physical geometry.
@ -311,6 +367,7 @@ impl BoxFragment {
children.iter().fold(PhysicalRect::zero(), |acc, child| {
acc.union(&child.scrollable_overflow(&containing_block))
});
BoxFragment {
base: base_fragment_info.into(),
style,
@ -324,6 +381,7 @@ impl BoxFragment {
margin,
block_margins_collapsed_with_children,
scrollable_overflow_from_children,
overconstrained,
}
}
@ -363,6 +421,7 @@ impl BoxFragment {
\nborder rect={:?}\
\nscrollable_overflow={:?}\
\noverflow={:?} / {:?}\
\noverconstrained={:?}
\nstyle={:p}",
self.base,
self.content_rect,
@ -371,6 +430,7 @@ impl BoxFragment {
self.scrollable_overflow(&PhysicalRect::zero()),
self.style.get_box().overflow_x,
self.style.get_box().overflow_y,
self.overconstrained,
self.style,
));
@ -414,6 +474,81 @@ impl BoxFragment {
overflow
}
pub(crate) fn calculate_resolved_insets_if_positioned(
&self,
containing_block: &PhysicalRect<CSSPixelLength>,
) -> PhysicalSides<CSSPixelLength> {
let position = self.style.get_box().position;
debug_assert_ne!(
position,
ComputedPosition::Static,
"Should not call this method on statically positioned box."
);
let (cb_width, cb_height) = (containing_block.width(), containing_block.height());
let content_rect = self
.content_rect
.to_physical(self.style.writing_mode, &containing_block);
// "A resolved value special case property like top defined in another
// specification If the property applies to a positioned element and the
// resolved value of the display property is not none or contents, and
// the property is not over-constrained, then the resolved value is the
// used value. Otherwise the resolved value is the computed value."
// https://drafts.csswg.org/cssom/#resolved-values
let insets = self.style.get_position();
if position == ComputedPosition::Relative {
let get_resolved_axis =
|start: &LengthPercentageOrAuto,
end: &LengthPercentageOrAuto,
container_length: CSSPixelLength| {
let start = start.map(|v| v.percentage_relative_to(container_length));
let end = end.map(|v| v.percentage_relative_to(container_length));
match (start.non_auto(), end.non_auto()) {
(None, None) => (Length::zero(), Length::zero()),
(None, Some(end)) => (-end, end),
(Some(start), None) => (start, -start),
// This is the overconstrained case, for which the resolved insets will
// simply be the computed insets.
(Some(start), Some(end)) => (start, end),
}
};
let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width);
let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height);
return PhysicalSides::new(top, right, bottom, left);
}
debug_assert!(
position == ComputedPosition::Fixed || position == ComputedPosition::Absolute,
"Got unknown position."
);
let resolve = |value: &LengthPercentageOrAuto, container_length| {
value
.auto_is(LengthPercentage::zero)
.percentage_relative_to(container_length)
};
let (top, bottom) = if self.overconstrained.height {
(
resolve(&insets.top, cb_height),
resolve(&insets.bottom, cb_height),
)
} else {
(content_rect.origin.y, cb_height - content_rect.max_y())
};
let (left, right) = if self.overconstrained.width {
(
resolve(&insets.left, cb_width),
resolve(&insets.right, cb_width),
)
} else {
(content_rect.origin.x, cb_width - content_rect.max_x())
};
PhysicalSides::new(top, right, bottom, left)
}
}
impl TextFragment {

257
components/layout_2020/positioned.rs
View file

@ -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 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 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 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 mut inline_axis = solve_inline_axis(computed_size.inline);
let mut block_axis = solve_block_axis(computed_size.block);
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 overconstrained = Vec2 {
inline: inline_axis_solver.is_overconstrained_for_size(computed_size.inline),
block: block_axis_solver.is_overconstrained_for_size(computed_size.block),
};
let mut inline_axis = inline_axis_solver.solve_for_size(computed_size.inline);
let mut block_axis = block_axis_solver.solve_for_size(computed_size.block);
let mut positioning_context =
PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap();
@ -519,7 +524,8 @@ impl HoistedAbsolutelyPositionedBox {
// https://drafts.csswg.org/css2/#min-max-widths (step 2)
if let Some(max) = max_size.inline {
if inline_size > max {
inline_axis = solve_inline_axis(LengthOrAuto::LengthPercentage(max));
inline_axis = inline_axis_solver
.solve_for_size(LengthOrAuto::LengthPercentage(max));
inline_size = inline_axis.size.auto_is(|| unreachable!());
}
}
@ -530,8 +536,8 @@ impl HoistedAbsolutelyPositionedBox {
// because a non-‘auto’ computed ‘inline-size’ always becomes the used value.
// https://drafts.csswg.org/css2/#min-max-widths (step 3)
if inline_size < min_size.inline {
inline_axis =
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);
box_offsets: &'a AbsoluteBoxOffsets,
}
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;
},
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

20
components/layout_2020/query.rs
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

324
tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini
View file

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

432
tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini
View file

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