diff options
26 files changed, 800 insertions, 1317 deletions
diff --git a/components/layout_2020/display_list/stacking_context.rs b/components/layout_2020/display_list/stacking_context.rs index ec61f829374..7f15a530863 100644 --- a/components/layout_2020/display_list/stacking_context.rs +++ b/components/layout_2020/display_list/stacking_context.rs @@ -5,6 +5,7 @@ use crate::cell::ArcRefCell; use crate::display_list::conversions::ToWebRender; use crate::display_list::DisplayListBuilder; +use crate::fragment_tree::ContainingBlockManager; use crate::fragments::{AnonymousFragment, BoxFragment, Fragment}; use crate::geom::PhysicalRect; use crate::style_ext::ComputedValuesExt; @@ -51,96 +52,6 @@ impl ContainingBlock { } } -#[derive(Clone)] -pub(crate) struct ContainingBlockManager<'a, T> { - // The containing block for all non-absolute descendants. "...if the element's - // position is 'relative' or 'static', the containing block is formed by the - // content edge of the nearest block container ancestor box." This is also - // the case for 'position: sticky' elements. - // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details - pub for_non_absolute_descendants: &'a T, - - // The containing block for absolute descendants. "If the element has - // 'position: absolute', the containing block is - // established by the nearest ancestor with a 'position' of 'absolute', - // 'relative' or 'fixed', in the following way: - // 1. In the case that the ancestor is an inline element, the containing - // block is the bounding box around the padding boxes of the first and the - // last inline boxes generated for that element. In CSS 2.1, if the inline - // element is split across multiple lines, the containing block is - // undefined. - // 2. Otherwise, the containing block is formed by the padding edge of the - // ancestor." - // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details - // If the ancestor forms a containing block for all descendants (see below), - // this value will be None and absolute descendants will use the containing - // block for fixed descendants. - pub for_absolute_descendants: Option<&'a T>, - - // The containing block for fixed and absolute descendants. - // "For elements whose layout is governed by the CSS box model, any value - // other than none for the transform property also causes the element to - // establish a containing block for all descendants. Its padding box will be - // used to layout for all of its absolute-position descendants, - // fixed-position descendants, and descendant fixed background attachments." - // https://w3c.github.io/csswg-drafts/css-transforms-1/#containing-block-for-all-descendants - // See `ComputedValues::establishes_containing_block_for_all_descendants` - // for a list of conditions where an element forms a containing block for - // all descendants. - pub for_absolute_and_fixed_descendants: &'a T, -} - -impl<'a, T> ContainingBlockManager<'a, T> { - fn get_containing_block_for_fragment(&self, fragment: &Fragment) -> &T { - if let Fragment::Box(box_fragment) = fragment { - match box_fragment.style.clone_position() { - ComputedPosition::Fixed => self.for_absolute_and_fixed_descendants, - ComputedPosition::Absolute => self - .for_absolute_descendants - .unwrap_or(self.for_absolute_and_fixed_descendants), - _ => self.for_non_absolute_descendants, - } - } else { - self.for_non_absolute_descendants - } - } - - pub(crate) fn new_for_non_absolute_descendants( - &self, - for_non_absolute_descendants: &'a T, - ) -> Self { - return ContainingBlockManager { - for_non_absolute_descendants, - for_absolute_descendants: self.for_absolute_descendants, - for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants, - }; - } - - pub(crate) fn new_for_absolute_descendants( - &self, - for_non_absolute_descendants: &'a T, - for_absolute_descendants: &'a T, - ) -> Self { - return ContainingBlockManager { - for_non_absolute_descendants, - for_absolute_descendants: Some(for_absolute_descendants), - for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants, - }; - } - - pub(crate) fn new_for_absolute_and_fixed_descendants( - &self, - for_non_absolute_descendants: &'a T, - for_absolute_and_fixed_descendants: &'a T, - ) -> Self { - return ContainingBlockManager { - for_non_absolute_descendants, - for_absolute_descendants: None, - for_absolute_and_fixed_descendants, - }; - } -} - pub(crate) type ContainingBlockInfo<'a> = ContainingBlockManager<'a, ContainingBlock>; #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] diff --git a/components/layout_2020/flow/root.rs b/components/layout_2020/flow/root.rs index c0ca277167c..f6eae6ea478 100644 --- a/components/layout_2020/flow/root.rs +++ b/components/layout_2020/flow/root.rs @@ -15,7 +15,7 @@ use crate::flow::float::FloatBox; use crate::flow::inline::InlineLevelBox; use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox}; use crate::formatting_contexts::IndependentFormattingContext; -use crate::fragment_tree::Tag; +use crate::fragment_tree::{ContainingBlockManager, Tag}; use crate::fragments::Fragment; use crate::geom::flow_relative::Vec2; use crate::geom::{PhysicalPoint, PhysicalRect, PhysicalSize}; @@ -457,11 +457,14 @@ impl FragmentTree { &self, mut process_func: impl FnMut(&Fragment, usize, &PhysicalRect<Length>) -> Option<T>, ) -> Option<T> { - self.root_fragments.iter().find_map(|child| { - child - .borrow() - .find(&self.initial_containing_block, 0, &mut process_func) - }) + let info = ContainingBlockManager { + for_non_absolute_descendants: &self.initial_containing_block, + for_absolute_descendants: None, + for_absolute_and_fixed_descendants: &self.initial_containing_block, + }; + self.root_fragments + .iter() + .find_map(|child| child.borrow().find(&info, 0, &mut process_func)) } pub fn remove_nodes_in_fragment_tree_from_set(&self, set: &mut FxHashSet<AnimationSetKey>) { diff --git a/components/layout_2020/fragment_tree/containing_block.rs b/components/layout_2020/fragment_tree/containing_block.rs new file mode 100644 index 00000000000..5bd02a67867 --- /dev/null +++ b/components/layout_2020/fragment_tree/containing_block.rs @@ -0,0 +1,99 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use crate::fragments::Fragment; +use style::computed_values::position::T as ComputedPosition; + +/// A data structure used to track the containing block when recursing +/// through the Fragment tree. It tracks the three types of containing +/// blocks (for all descendants, for absolute and fixed position +/// descendants, and for fixed position descendants). +pub(crate) struct ContainingBlockManager<'a, T> { + // The containing block for all non-absolute descendants. "...if the element's + // position is 'relative' or 'static', the containing block is formed by the + // content edge of the nearest block container ancestor box." This is also + // the case for 'position: sticky' elements. + // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details + pub for_non_absolute_descendants: &'a T, + + // The containing block for absolute descendants. "If the element has + // 'position: absolute', the containing block is + // established by the nearest ancestor with a 'position' of 'absolute', + // 'relative' or 'fixed', in the following way: + // 1. In the case that the ancestor is an inline element, the containing + // block is the bounding box around the padding boxes of the first and the + // last inline boxes generated for that element. In CSS 2.1, if the inline + // element is split across multiple lines, the containing block is + // undefined. + // 2. Otherwise, the containing block is formed by the padding edge of the + // ancestor." + // https://www.w3.org/TR/CSS2/visudet.html#containing-block-details + // If the ancestor forms a containing block for all descendants (see below), + // this value will be None and absolute descendants will use the containing + // block for fixed descendants. + pub for_absolute_descendants: Option<&'a T>, + + // The containing block for fixed and absolute descendants. + // "For elements whose layout is governed by the CSS box model, any value + // other than none for the transform property also causes the element to + // establish a containing block for all descendants. Its padding box will be + // used to layout for all of its absolute-position descendants, + // fixed-position descendants, and descendant fixed background attachments." + // https://w3c.github.io/csswg-drafts/css-transforms-1/#containing-block-for-all-descendants + // See `ComputedValues::establishes_containing_block_for_all_descendants` + // for a list of conditions where an element forms a containing block for + // all descendants. + pub for_absolute_and_fixed_descendants: &'a T, +} + +impl<'a, T> ContainingBlockManager<'a, T> { + pub(crate) fn get_containing_block_for_fragment(&self, fragment: &Fragment) -> &T { + if let Fragment::Box(box_fragment) = fragment { + match box_fragment.style.clone_position() { + ComputedPosition::Fixed => self.for_absolute_and_fixed_descendants, + ComputedPosition::Absolute => self + .for_absolute_descendants + .unwrap_or(self.for_absolute_and_fixed_descendants), + _ => self.for_non_absolute_descendants, + } + } else { + self.for_non_absolute_descendants + } + } + + pub(crate) fn new_for_non_absolute_descendants( + &self, + for_non_absolute_descendants: &'a T, + ) -> Self { + return ContainingBlockManager { + for_non_absolute_descendants, + for_absolute_descendants: self.for_absolute_descendants, + for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants, + }; + } + + pub(crate) fn new_for_absolute_descendants( + &self, + for_non_absolute_descendants: &'a T, + for_absolute_descendants: &'a T, + ) -> Self { + return ContainingBlockManager { + for_non_absolute_descendants, + for_absolute_descendants: Some(for_absolute_descendants), + for_absolute_and_fixed_descendants: self.for_absolute_and_fixed_descendants, + }; + } + + pub(crate) fn new_for_absolute_and_fixed_descendants( + &self, + for_non_absolute_descendants: &'a T, + for_absolute_and_fixed_descendants: &'a T, + ) -> Self { + return ContainingBlockManager { + for_non_absolute_descendants, + for_absolute_descendants: None, + for_absolute_and_fixed_descendants, + }; + } +} diff --git a/components/layout_2020/fragment_tree/mod.rs b/components/layout_2020/fragment_tree/mod.rs index 1d7425655cb..96f07217ac4 100644 --- a/components/layout_2020/fragment_tree/mod.rs +++ b/components/layout_2020/fragment_tree/mod.rs @@ -3,5 +3,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ mod base; +mod containing_block; pub(crate) use base::*; +pub(crate) use containing_block::*; diff --git a/components/layout_2020/fragments.rs b/components/layout_2020/fragments.rs index 53e6d93cdc1..4dbacf10182 100644 --- a/components/layout_2020/fragments.rs +++ b/components/layout_2020/fragments.rs @@ -3,10 +3,11 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use crate::cell::ArcRefCell; -use crate::fragment_tree::{BaseFragment, BaseFragmentInfo, Tag}; +use crate::fragment_tree::{BaseFragment, BaseFragmentInfo, ContainingBlockManager, Tag}; use crate::geom::flow_relative::{Rect, Sides}; -use crate::geom::{PhysicalPoint, PhysicalRect}; +use crate::geom::{PhysicalPoint, PhysicalRect, PhysicalSides, PhysicalSize}; use crate::positioned::HoistedSharedFragment; +use crate::style_ext::ComputedValuesExt; use gfx::font::FontMetrics as GfxFontMetrics; use gfx::text::glyph::GlyphStore; use gfx_traits::print_tree::PrintTree; @@ -14,9 +15,10 @@ use msg::constellation_msg::{BrowsingContextId, PipelineId}; use servo_arc::Arc as ServoArc; use std::sync::Arc; use style::computed_values::overflow_x::T as ComputedOverflow; +use style::computed_values::position::T as ComputedPosition; use style::logical_geometry::WritingMode; use style::properties::ComputedValues; -use style::values::computed::Length; +use style::values::computed::{CSSPixelLength, Length, LengthPercentage, LengthPercentageOrAuto}; use style::values::specified::text::TextDecorationLine; use style::Zero; use webrender_api::{FontInstanceKey, ImageKey}; @@ -59,6 +61,9 @@ pub(crate) struct BoxFragment { /// The scrollable overflow of this box fragment. pub scrollable_overflow_from_children: PhysicalRect<Length>, + + /// Whether or not this box was overconstrained in the given dimension. + overconstrained: PhysicalSize<bool>, } #[derive(Serialize)] @@ -207,36 +212,54 @@ impl Fragment { pub(crate) fn find<T>( &self, - containing_block: &PhysicalRect<Length>, + manager: &ContainingBlockManager<PhysicalRect<Length>>, level: usize, process_func: &mut impl FnMut(&Fragment, usize, &PhysicalRect<Length>) -> Option<T>, ) -> Option<T> { + let containing_block = manager.get_containing_block_for_fragment(self); if let Some(result) = process_func(self, level, containing_block) { return Some(result); } match self { Fragment::Box(fragment) => { - let new_containing_block = fragment + let content_rect = fragment .content_rect .to_physical(fragment.style.writing_mode, containing_block) .translate(containing_block.origin.to_vector()); - fragment.children.iter().find_map(|child| { - child - .borrow() - .find(&new_containing_block, level + 1, process_func) - }) + let padding_rect = fragment + .padding_rect() + .to_physical(fragment.style.writing_mode, containing_block) + .translate(containing_block.origin.to_vector()); + let new_manager = if fragment + .style + .establishes_containing_block_for_all_descendants() + { + manager.new_for_absolute_and_fixed_descendants(&content_rect, &padding_rect) + } else if fragment + .style + .establishes_containing_block_for_absolute_descendants() + { + manager.new_for_absolute_descendants(&content_rect, &padding_rect) + } else { + manager.new_for_non_absolute_descendants(&content_rect) + }; + + fragment + .children + .iter() + .find_map(|child| child.borrow().find(&new_manager, level + 1, process_func)) }, Fragment::Anonymous(fragment) => { - let new_containing_block = fragment + let content_rect = fragment .rect .to_physical(fragment.mode, containing_block) .translate(containing_block.origin.to_vector()); - fragment.children.iter().find_map(|child| { - child - .borrow() - .find(&new_containing_block, level + 1, process_func) - }) + let new_manager = manager.new_for_non_absolute_descendants(&content_rect); + fragment + .children + .iter() + .find_map(|child| child.borrow().find(&new_manager, level + 1, process_func)) }, _ => None, } @@ -304,6 +327,39 @@ impl BoxFragment { margin: Sides<Length>, block_margins_collapsed_with_children: CollapsedBlockMargins, ) -> BoxFragment { + let position = style.get_box().position; + let insets = style.get_position(); + let width_overconstrained = position == ComputedPosition::Relative && + !insets.left.is_auto() && + !insets.right.is_auto(); + let height_overconstrained = position == ComputedPosition::Relative && + !insets.left.is_auto() && + !insets.bottom.is_auto(); + + Self::new_with_overconstrained( + base_fragment_info, + style, + children, + content_rect, + padding, + border, + margin, + block_margins_collapsed_with_children, + PhysicalSize::new(width_overconstrained, height_overconstrained), + ) + } + + pub fn new_with_overconstrained( + base_fragment_info: BaseFragmentInfo, + style: ServoArc<ComputedValues>, + children: Vec<Fragment>, + content_rect: Rect<Length>, + padding: Sides<Length>, + border: Sides<Length>, + margin: Sides<Length>, + block_margins_collapsed_with_children: CollapsedBlockMargins, + overconstrained: PhysicalSize<bool>, + ) -> BoxFragment { // FIXME(mrobinson, bug 25564): We should be using the containing block // here to properly convert scrollable overflow to physical geometry. let containing_block = PhysicalRect::zero(); @@ -311,6 +367,7 @@ impl BoxFragment { children.iter().fold(PhysicalRect::zero(), |acc, child| { acc.union(&child.scrollable_overflow(&containing_block)) }); + BoxFragment { base: base_fragment_info.into(), style, @@ -324,6 +381,7 @@ impl BoxFragment { margin, block_margins_collapsed_with_children, scrollable_overflow_from_children, + overconstrained, } } @@ -363,6 +421,7 @@ impl BoxFragment { \nborder rect={:?}\ \nscrollable_overflow={:?}\ \noverflow={:?} / {:?}\ + \noverconstrained={:?} \nstyle={:p}", self.base, self.content_rect, @@ -371,6 +430,7 @@ impl BoxFragment { self.scrollable_overflow(&PhysicalRect::zero()), self.style.get_box().overflow_x, self.style.get_box().overflow_y, + self.overconstrained, self.style, )); @@ -414,6 +474,81 @@ impl BoxFragment { overflow } + + pub(crate) fn calculate_resolved_insets_if_positioned( + &self, + containing_block: &PhysicalRect<CSSPixelLength>, + ) -> PhysicalSides<CSSPixelLength> { + let position = self.style.get_box().position; + debug_assert_ne!( + position, + ComputedPosition::Static, + "Should not call this method on statically positioned box." + ); + + let (cb_width, cb_height) = (containing_block.width(), containing_block.height()); + let content_rect = self + .content_rect + .to_physical(self.style.writing_mode, &containing_block); + + // "A resolved value special case property like top defined in another + // specification If the property applies to a positioned element and the + // resolved value of the display property is not none or contents, and + // the property is not over-constrained, then the resolved value is the + // used value. Otherwise the resolved value is the computed value." + // https://drafts.csswg.org/cssom/#resolved-values + let insets = self.style.get_position(); + if position == ComputedPosition::Relative { + let get_resolved_axis = + |start: &LengthPercentageOrAuto, + end: &LengthPercentageOrAuto, + container_length: CSSPixelLength| { + let start = start.map(|v| v.percentage_relative_to(container_length)); + let end = end.map(|v| v.percentage_relative_to(container_length)); + match (start.non_auto(), end.non_auto()) { + (None, None) => (Length::zero(), Length::zero()), + (None, Some(end)) => (-end, end), + (Some(start), None) => (start, -start), + // This is the overconstrained case, for which the resolved insets will + // simply be the computed insets. + (Some(start), Some(end)) => (start, end), + } + }; + let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width); + let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height); + return PhysicalSides::new(top, right, bottom, left); + } + + debug_assert!( + position == ComputedPosition::Fixed || position == ComputedPosition::Absolute, + "Got unknown position." + ); + + let resolve = |value: &LengthPercentageOrAuto, container_length| { + value + .auto_is(LengthPercentage::zero) + .percentage_relative_to(container_length) + }; + + let (top, bottom) = if self.overconstrained.height { + ( + resolve(&insets.top, cb_height), + resolve(&insets.bottom, cb_height), + ) + } else { + (content_rect.origin.y, cb_height - content_rect.max_y()) + }; + let (left, right) = if self.overconstrained.width { + ( + resolve(&insets.left, cb_width), + resolve(&insets.right, cb_width), + ) + } else { + (content_rect.origin.x, cb_width - content_rect.max_x()) + }; + + PhysicalSides::new(top, right, bottom, left) + } } impl TextFragment { diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index 744086ebc93..0a7dd28e945 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -93,6 +93,13 @@ pub(crate) enum AbsoluteBoxOffsets { } impl AbsoluteBoxOffsets { + fn both_specified(&self) -> bool { + match self { + AbsoluteBoxOffsets::Both { .. } => return true, + _ => return false, + } + } + fn adjust_offset(&mut self, new_offset: Length) { match *self { AbsoluteBoxOffsets::StaticStart { ref mut start } => *start = new_offset, @@ -444,32 +451,30 @@ impl HoistedAbsolutelyPositionedBox { }; let shared_fragment = self.fragment.borrow(); + let inline_axis_solver = AbsoluteAxisSolver { + containing_size: cbis, + padding_border_sum: pbm.padding_border_sums.inline, + computed_margin_start: pbm.margin.inline_start, + computed_margin_end: pbm.margin.inline_end, + avoid_negative_margin_start: true, + box_offsets: &shared_fragment.box_offsets.inline, + }; - let solve_inline_axis = |computed_size| { - solve_axis( - cbis, - pbm.padding_border_sums.inline, - pbm.margin.inline_start, - pbm.margin.inline_end, - /* avoid_negative_margin_start */ true, - &shared_fragment.box_offsets.inline, - computed_size, - ) + let block_axis_solver = AbsoluteAxisSolver { + containing_size: cbbs, + padding_border_sum: pbm.padding_border_sums.block, + computed_margin_start: pbm.margin.block_start, + computed_margin_end: pbm.margin.block_end, + avoid_negative_margin_start: false, + box_offsets: &shared_fragment.box_offsets.block, }; - let solve_block_axis = |computed_size| { - solve_axis( - cbbs, - pbm.padding_border_sums.block, - pbm.margin.block_start, - pbm.margin.block_end, - /* avoid_negative_margin_start */ false, - &shared_fragment.box_offsets.block, - computed_size, - ) + let overconstrained = Vec2 { + inline: inline_axis_solver.is_overconstrained_for_size(computed_size.inline), + block: block_axis_solver.is_overconstrained_for_size(computed_size.block), }; - let mut inline_axis = solve_inline_axis(computed_size.inline); - let mut block_axis = solve_block_axis(computed_size.block); + let mut inline_axis = inline_axis_solver.solve_for_size(computed_size.inline); + let mut block_axis = block_axis_solver.solve_for_size(computed_size.block); let mut positioning_context = PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap(); @@ -519,7 +524,8 @@ impl HoistedAbsolutelyPositionedBox { // https://drafts.csswg.org/css2/#min-max-widths (step 2) if let Some(max) = max_size.inline { if inline_size > max { - inline_axis = solve_inline_axis(LengthOrAuto::LengthPercentage(max)); + inline_axis = inline_axis_solver + .solve_for_size(LengthOrAuto::LengthPercentage(max)); inline_size = inline_axis.size.auto_is(|| unreachable!()); } } @@ -530,8 +536,8 @@ impl HoistedAbsolutelyPositionedBox { // because a non-‘auto’ computed ‘inline-size’ always becomes the used value. // https://drafts.csswg.org/css2/#min-max-widths (step 3) if inline_size < min_size.inline { - inline_axis = - solve_inline_axis(LengthOrAuto::LengthPercentage(min_size.inline)); + inline_axis = inline_axis_solver + .solve_for_size(LengthOrAuto::LengthPercentage(min_size.inline)); inline_size = inline_axis.size.auto_is(|| unreachable!()); } @@ -581,7 +587,8 @@ impl HoistedAbsolutelyPositionedBox { // https://drafts.csswg.org/css2/#min-max-heights (step 2) if let Some(max) = max_size.block { if result.content_size.block > max { - block_axis = solve_block_axis(LengthOrAuto::LengthPercentage(max)); + block_axis = block_axis_solver + .solve_for_size(LengthOrAuto::LengthPercentage(max)); result = try_layout(LengthOrAuto::LengthPercentage(max)); } } @@ -592,8 +599,8 @@ impl HoistedAbsolutelyPositionedBox { // because a non-‘auto’ computed ‘block-size’ always becomes the used value. // https://drafts.csswg.org/css2/#min-max-heights (step 3) if result.content_size.block < min_size.block { - block_axis = - solve_block_axis(LengthOrAuto::LengthPercentage(min_size.block)); + block_axis = block_axis_solver + .solve_for_size(LengthOrAuto::LengthPercentage(min_size.block)); result = try_layout(LengthOrAuto::LengthPercentage(min_size.block)); } @@ -631,7 +638,10 @@ impl HoistedAbsolutelyPositionedBox { size: content_size, }; - BoxFragment::new( + let physical_overconstrained = + overconstrained.to_physical(containing_block.style.writing_mode); + + BoxFragment::new_with_overconstrained( absolutely_positioned_box.context.base_fragment_info(), absolutely_positioned_box.context.style().clone(), fragments, @@ -640,6 +650,7 @@ impl HoistedAbsolutelyPositionedBox { pbm.border, margin, CollapsedBlockMargins::zero(), + physical_overconstrained, ) }; positioning_context.layout_collected_children(layout_context, &mut new_fragment); @@ -661,97 +672,111 @@ struct AxisResult { margin_end: Length, } -/// This unifies some of the parts in common in: -/// -/// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-width -/// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-height -/// -/// … and: -/// -/// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-width -/// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-height -/// -/// In the replaced case, `size` is never `Auto`. -fn solve_axis( +struct AbsoluteAxisSolver<'a> { containing_size: Length, padding_border_sum: Length, computed_margin_start: LengthOrAuto, computed_margin_end: LengthOrAuto, avoid_negative_margin_start: bool, - box_offsets: &AbsoluteBoxOffsets, - computed_size: LengthOrAuto, -) -> AxisResult { - match box_offsets { - AbsoluteBoxOffsets::StaticStart { start } => AxisResult { - anchor: Anchor::Start(*start), - size: computed_size, - margin_start: computed_margin_start.auto_is(Length::zero), - margin_end: computed_margin_end.auto_is(Length::zero), - }, - AbsoluteBoxOffsets::Start { start } => AxisResult { - anchor: Anchor::Start(start.percentage_relative_to(containing_size)), - size: computed_size, - margin_start: computed_margin_start.auto_is(Length::zero), - margin_end: computed_margin_end.auto_is(Length::zero), - }, - AbsoluteBoxOffsets::End { end } => AxisResult { - anchor: Anchor::End(end.percentage_relative_to(containing_size)), - size: computed_size, - margin_start: computed_margin_start.auto_is(Length::zero), - margin_end: computed_margin_end.auto_is(Length::zero), - }, - AbsoluteBoxOffsets::Both { start, end } => { - let start = start.percentage_relative_to(containing_size); - let end = end.percentage_relative_to(containing_size); - - let margin_start; - let margin_end; - let used_size; - if let LengthOrAuto::LengthPercentage(s) = computed_size { - used_size = s; - let margins = containing_size - start - end - padding_border_sum - s; - match (computed_margin_start, computed_margin_end) { - (LengthOrAuto::Auto, LengthOrAuto::Auto) => { - if avoid_negative_margin_start && margins < Length::zero() { - margin_start = Length::zero(); - margin_end = margins; - } else { - margin_start = margins / 2.; - margin_end = margins / 2.; - } - }, - (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => { - margin_start = margins - end; - margin_end = end; - }, - (LengthOrAuto::LengthPercentage(start), LengthOrAuto::Auto) => { - margin_start = start; - margin_end = margins - start; - }, - ( - LengthOrAuto::LengthPercentage(start), - LengthOrAuto::LengthPercentage(end), - ) => { - margin_start = start; - margin_end = end; - }, + box_offsets: &'a AbsoluteBoxOffsets, +} + +impl<'a> AbsoluteAxisSolver<'a> { + /// This unifies some of the parts in common in: + /// + /// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-width + /// * https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-height + /// + /// … and: + /// + /// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-width + /// * https://drafts.csswg.org/css2/visudet.html#abs-replaced-height + /// + /// In the replaced case, `size` is never `Auto`. + fn solve_for_size(&self, computed_size: LengthOrAuto) -> AxisResult { + match self.box_offsets { + AbsoluteBoxOffsets::StaticStart { start } => AxisResult { + anchor: Anchor::Start(*start), + size: computed_size, + margin_start: self.computed_margin_start.auto_is(Length::zero), + margin_end: self.computed_margin_end.auto_is(Length::zero), + }, + AbsoluteBoxOffsets::Start { start } => AxisResult { + anchor: Anchor::Start(start.percentage_relative_to(self.containing_size)), + size: computed_size, + margin_start: self.computed_margin_start.auto_is(Length::zero), + margin_end: self.computed_margin_end.auto_is(Length::zero), + }, + AbsoluteBoxOffsets::End { end } => AxisResult { + anchor: Anchor::End(end.percentage_relative_to(self.containing_size)), + size: computed_size, + margin_start: self.computed_margin_start.auto_is(Length::zero), + margin_end: self.computed_margin_end.auto_is(Length::zero), + }, + AbsoluteBoxOffsets::Both { start, end } => { + let start = start.percentage_relative_to(self.containing_size); + let end = end.percentage_relative_to(self.containing_size); + + let margin_start; + let margin_end; + let used_size; + if let LengthOrAuto::LengthPercentage(s) = computed_size { + used_size = s; + let margins = self.containing_size - start - end - self.padding_border_sum - s; + match (self.computed_margin_start, self.computed_margin_end) { + (LengthOrAuto::Auto, LengthOrAuto::Auto) => { + if self.avoid_negative_margin_start && margins < Length::zero() { + margin_start = Length::zero(); + margin_end = margins; + } else { + margin_start = margins / 2.; + margin_end = margins / 2.; + } + }, + (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => { + margin_start = margins - end; + margin_end = end; + }, + (LengthOrAuto::LengthPercentage(start), LengthOrAuto::Auto) => { + margin_start = start; + margin_end = margins - start; + }, + ( + LengthOrAuto::LengthPercentage(start), + LengthOrAuto::LengthPercentage(end), + ) => { + margin_start = start; + margin_end = end; + }, + } + } else { + margin_start = self.computed_margin_start.auto_is(Length::zero); + margin_end = self.computed_margin_end.auto_is(Length::zero); + + // This may be negative, but the caller will later effectively + // clamp it to ‘min-inline-size’ or ‘min-block-size’. + used_size = self.containing_size - + start - + end - + self.padding_border_sum - + margin_start - + margin_end; + }; + AxisResult { + anchor: Anchor::Start(start), + size: LengthOrAuto::LengthPercentage(used_size), + margin_start, + margin_end, } - } else { - margin_start = computed_margin_start.auto_is(Length::zero); - margin_end = computed_margin_end.auto_is(Length::zero); + }, + } + } - // This may be negative, but the caller will later effectively - // clamp it to ‘min-inline-size’ or ‘min-block-size’. - used_size = - containing_size - start - end - padding_border_sum - margin_start - margin_end - }; - AxisResult { - anchor: Anchor::Start(start), - size: LengthOrAuto::LengthPercentage(used_size), - margin_start, - margin_end, - } - }, + fn is_overconstrained_for_size(&self, computed_size: LengthOrAuto) -> bool { + !computed_size.is_auto() && + self.box_offsets.both_specified() && + !self.computed_margin_start.is_auto() && + !self.computed_margin_end.is_auto() } } @@ -796,6 +821,10 @@ pub(crate) fn relative_adjustement( style: &ComputedValues, containing_block: &ContainingBlock, ) -> Vec2<Length> { + // "If the height of the containing block is not specified explicitly (i.e., + // it depends on content height), and this element is not absolutely + // positioned, the value computes to 'auto'."" + // https://www.w3.org/TR/CSS2/visudet.html#the-height-property let cbis = containing_block.inline_size; let cbbs = containing_block.block_size.auto_is(Length::zero); let box_offsets = style diff --git a/components/layout_2020/query.rs b/components/layout_2020/query.rs index 769bb9641d8..74420ae2bb5 100644 --- a/components/layout_2020/query.rs +++ b/components/layout_2020/query.rs @@ -306,7 +306,18 @@ pub fn process_resolved_style_request<'dom>( _ => return None, }; - let positioned = style.get_box().position != Position::Static; + if style.get_box().position != Position::Static { + let resolved_insets = + || box_fragment.calculate_resolved_insets_if_positioned(containing_block); + match longhand_id { + LonghandId::Top => return Some(resolved_insets().top.to_css_string()), + LonghandId::Right => return Some(resolved_insets().right.to_css_string()), + LonghandId::Bottom => return Some(resolved_insets().bottom.to_css_string()), + LonghandId::Left => return Some(resolved_insets().left.to_css_string()), + _ => {}, + } + } + let content_rect = box_fragment .content_rect .to_physical(box_fragment.style.writing_mode, &containing_block); @@ -327,13 +338,6 @@ pub fn process_resolved_style_request<'dom>( LonghandId::PaddingTop => Some(padding.top), LonghandId::PaddingLeft => Some(padding.left), LonghandId::PaddingRight => Some(padding.right), - // TODO(mrobinson): These following values are often wrong, because these are not - // exactly the "used value" for the positional properties. The real used values are - // lost by the time the Fragment tree is constructed, so we may need to record them in - // the tree to properly answer this query. That said, we can return an okayish value - // sometimes simply by using the calculated position in the containing block. - LonghandId::Top if positioned => Some(content_rect.origin.y), - LonghandId::Left if positioned => Some(content_rect.origin.x), _ => None, } .map(|value| value.to_css_string()) diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini index 9f15e63c8d9..251c8f6c5f5 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini @@ -34,3 +34,39 @@ [.container > div 24] expected: FAIL + + [.container > div 2] + expected: FAIL + + [.container > div 3] + expected: FAIL + + [.container > div 4] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 14] + expected: FAIL + + [.container > div 15] + expected: FAIL + + [.container > div 16] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini index 6de34f368f1..00a3689c467 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini @@ -46,3 +46,27 @@ [.container > div 23] expected: FAIL + + [.container > div 4] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 16] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini index f23bdda21e3..bff7f467a85 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini @@ -34,3 +34,39 @@ [.container > div 24] expected: FAIL + + [.container > div 2] + expected: FAIL + + [.container > div 3] + expected: FAIL + + [.container > div 4] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 14] + expected: FAIL + + [.container > div 15] + expected: FAIL + + [.container > div 16] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini index 4f09d72fc23..33a95e61976 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini @@ -46,3 +46,27 @@ [.container > div 23] expected: FAIL + + [.container > div 4] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 16] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini index 0fcdd177ed0..cbb682aa9ca 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini @@ -46,3 +46,27 @@ [.container > div 23] expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 17] + expected: FAIL + + [.container > div 20] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini index 1e0f35df40f..20e9970b2b5 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini @@ -46,3 +46,27 @@ [.container > div 23] expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 17] + expected: FAIL + + [.container > div 20] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini index 5e9407d901d..f1042ded7b6 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini @@ -58,3 +58,27 @@ [.container > div 28] expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 24] + expected: FAIL + + [.container > div 26] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini index 23d4519fbcc..40572dbccfc 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini @@ -58,3 +58,27 @@ [.container > div 28] expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 23] + expected: FAIL + + [.container > div 26] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini index a8b41b96e70..7bdf31edac6 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini @@ -34,3 +34,39 @@ [.container > div 24] expected: FAIL + + [.container > div 1] + expected: FAIL + + [.container > div 2] + expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 13] + expected: FAIL + + [.container > div 14] + expected: FAIL + + [.container > div 17] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini index 04e162cafaf..325cd7b8c33 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini @@ -52,3 +52,21 @@ [.container > div 24] expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini index 46ba3268235..25e32718ee3 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini @@ -28,3 +28,45 @@ [.container > div 22] expected: FAIL + + [.container > div 1] + expected: FAIL + + [.container > div 2] + expected: FAIL + + [.container > div 5] + expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 9] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 13] + expected: FAIL + + [.container > div 14] + expected: FAIL + + [.container > div 17] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 21] + expected: FAIL + + [.container > div 23] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini index 0c925cc8c38..42a8cdeaff2 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini @@ -46,3 +46,27 @@ [.container > div 21] expected: FAIL + + [.container > div 7] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 12] + expected: FAIL + + [.container > div 19] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 23] + expected: FAIL + + [.container > div 24] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini index 5e0efe959a6..0dbbe7112d3 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini @@ -52,3 +52,21 @@ [.container > div 24] expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 20] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini index cf325fab510..0d4a746af2f 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini @@ -52,3 +52,21 @@ [.container > div 24] expected: FAIL + + [.container > div 8] + expected: FAIL + + [.container > div 10] + expected: FAIL + + [.container > div 11] + expected: FAIL + + [.container > div 20] + expected: FAIL + + [.container > div 22] + expected: FAIL + + [.container > div 23] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini index 1d51f307e09..514a578845e 100644 --- a/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini +++ b/tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini @@ -22,3 +22,15 @@ [.rect 16] expected: FAIL + + [.rect 1] + expected: FAIL + + [.rect 2] + expected: FAIL + + [.rect 3] + expected: FAIL + + [.rect 4] + expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini index eb59a9cdab5..1da4114a01c 100644 --- a/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini +++ b/tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini @@ -1,7 +1,3 @@ [computed-style-005.html] - [relative_computed_left_and_right] - expected: FAIL - [absolute_computed_left_and_right] expected: FAIL - diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini index 7b5b8af0734..4831f60d4bd 100644 --- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini +++ b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini @@ -2,75 +2,18 @@ [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -83,222 +26,90 @@ [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -308,66 +119,27 @@ [vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -377,42 +149,21 @@ [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL @@ -422,42 +173,21 @@ [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -467,74 +197,20 @@ [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini index 6accdda38d8..9498584170e 100644 --- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini +++ b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini @@ -2,75 +2,18 @@ [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -83,222 +26,90 @@ [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -308,66 +119,27 @@ [vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -377,42 +149,21 @@ [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL @@ -422,42 +173,21 @@ [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL [vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL @@ -467,74 +197,20 @@ [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL - [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained] expected: FAIL [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] expected: FAIL [horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained] expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL diff --git a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini b/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini deleted file mode 100644 index 5fbcc1e89ee..00000000000 --- a/tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini +++ /dev/null @@ -1,432 +0,0 @@ -[getComputedStyle-insets-relative.html] - [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels] - expected: FAIL - - [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels] - expected: FAIL - - [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value] - expected: FAIL - - [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels] - expected: FAIL - - [vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels] - expected: FAIL |