Add initial support for sticky positioning for non-legacy layout (#30686)

* Add initial support for sticky positioning for non-legacy layout

Many tests still fail for a variety of reasons. One of the primary ones
is that CSSOM currently does not return correct values for elements
positioned by sticky nodes. This requires changes to WebRender to work
properly.

* Fix an assertion failure in the legacy layout sticky code
This commit is contained in:
Martin Robinson 2023-11-29 10:03:24 +01:00 committed by GitHub
parent bab2b58216
commit a05598402e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
37 changed files with 248 additions and 1206 deletions

View file

@ -2593,11 +2593,10 @@ impl BlockFlow {
// order to properly calculate max offsets we need to compare our size and
// position in our parent's coordinate system.
let border_box_in_parent = self.stacking_relative_border_box(CoordinateSystem::Parent);
let margins = self.fragment.margin.to_physical(
self.base
.early_absolute_position_info
.relative_containing_block_mode,
);
let margins = self
.fragment
.margin
.to_physical(self.fragment.style.writing_mode);
// Position:sticky elements are always restricted based on the size and position of
// their containing block, which for sticky items is like relative and statically

View file

@ -6,6 +6,7 @@ use std::cell::RefCell;
use std::mem;
use euclid::default::Rect;
use euclid::SideOffsets2D;
use gfx_traits::print_tree::PrintTree;
use log::warn;
use script_traits::compositor::{ScrollTreeNodeId, ScrollableNodeInfo};
@ -23,6 +24,8 @@ use style::values::specified::box_::DisplayOutside;
use webrender_api as wr;
use webrender_api::units::{LayoutPoint, LayoutRect, LayoutTransform, LayoutVector2D};
use webrender_api::ScrollSensitivity;
use wr::units::{LayoutPixel, LayoutSize};
use wr::StickyOffsetBounds;
use super::DisplayList;
use crate::cell::ArcRefCell;
@ -31,7 +34,7 @@ use crate::display_list::DisplayListBuilder;
use crate::fragment_tree::{
AnonymousFragment, BoxFragment, ContainingBlockManager, Fragment, FragmentTree,
};
use crate::geom::PhysicalRect;
use crate::geom::{PhysicalRect, PhysicalSides};
use crate::style_ext::ComputedValuesExt;
#[derive(Clone)]
@ -40,6 +43,11 @@ pub(crate) struct ContainingBlock {
/// of this containing block.
scroll_node_id: ScrollTreeNodeId,
/// The size of the parent scroll frame of this containing block, used for resolving
/// sticky margins. If this is None, then this is a direct descendant of a reference
/// frame and sticky positioning isn't taken into account.
scroll_frame_size: Option<LayoutSize>,
/// The WebRender ClipId to use for this children of this containing
/// block.
clip_chain_id: wr::ClipChainId,
@ -50,14 +58,16 @@ pub(crate) struct ContainingBlock {
impl ContainingBlock {
pub(crate) fn new(
rect: &PhysicalRect<Length>,
rect: PhysicalRect<Length>,
scroll_node_id: ScrollTreeNodeId,
scroll_frame_size: Option<LayoutSize>,
clip_chain_id: wr::ClipChainId,
) -> Self {
ContainingBlock {
scroll_node_id,
scroll_frame_size,
clip_chain_id,
rect: *rect,
rect,
}
}
@ -90,13 +100,15 @@ impl DisplayList {
.define_clip_chain(None, [wr::ClipId::root(self.wr.pipeline_id)]);
let cb_for_non_fixed_descendants = ContainingBlock::new(
&fragment_tree.initial_containing_block,
fragment_tree.initial_containing_block,
self.compositor_info.root_scroll_node_id,
Some(self.compositor_info.viewport_size),
root_clip_chain_id,
);
let cb_for_fixed_descendants = ContainingBlock::new(
&fragment_tree.initial_containing_block,
fragment_tree.initial_containing_block,
self.compositor_info.root_reference_frame_id,
None,
root_clip_chain_id,
);
@ -114,7 +126,7 @@ impl DisplayList {
let mut root_stacking_context = StackingContext::create_root(&self.wr, debug);
for fragment in &fragment_tree.root_fragments {
fragment.borrow().build_stacking_context_tree(
fragment.borrow_mut().build_stacking_context_tree(
fragment,
self,
&containing_block_info,
@ -197,6 +209,29 @@ impl DisplayList {
);
(new_scroll_node_id, new_clip_chain_id)
}
fn define_sticky_frame(
&mut self,
parent_scroll_node_id: &ScrollTreeNodeId,
frame_rect: LayoutRect,
margins: SideOffsets2D<Option<f32>, LayoutPixel>,
vertical_offset_bounds: StickyOffsetBounds,
horizontal_offset_bounds: StickyOffsetBounds,
) -> ScrollTreeNodeId {
let new_spatial_id = self.wr.define_sticky_frame(
parent_scroll_node_id.spatial_id,
frame_rect,
margins,
vertical_offset_bounds,
horizontal_offset_bounds,
LayoutVector2D::zero(),
);
self.compositor_info.scroll_tree.add_scroll_tree_node(
Some(parent_scroll_node_id),
new_spatial_id,
None,
)
}
}
/// A piece of content that directly belongs to a section of a stacking context.
@ -769,7 +804,7 @@ pub(crate) enum StackingContextBuildMode {
impl Fragment {
pub(crate) fn build_stacking_context_tree(
&self,
&mut self,
fragment_ref: &ArcRefCell<Fragment>,
display_list: &mut DisplayList,
containing_block_info: &ContainingBlockInfo,
@ -810,7 +845,7 @@ impl Fragment {
None => unreachable!("Found hoisted box with missing fragment."),
};
fragment_ref.borrow().build_stacking_context_tree(
fragment_ref.borrow_mut().build_stacking_context_tree(
fragment_ref,
display_list,
containing_block_info,
@ -882,7 +917,7 @@ impl BoxFragment {
}
fn build_stacking_context_tree(
&self,
&mut self,
fragment: &ArcRefCell<Fragment>,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
@ -899,7 +934,7 @@ impl BoxFragment {
}
fn build_stacking_context_tree_maybe_creating_reference_frame(
&self,
&mut self,
fragment: &ArcRefCell<Fragment>,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
@ -941,10 +976,11 @@ impl BoxFragment {
.style
.establishes_containing_block_for_all_descendants());
let adjusted_containing_block = ContainingBlock::new(
&containing_block
containing_block
.rect
.translate(-reference_frame_data.origin.to_vector()),
new_spatial_id,
None,
containing_block.clip_chain_id,
);
let new_containing_block_info =
@ -962,7 +998,7 @@ impl BoxFragment {
}
fn build_stacking_context_tree_maybe_creating_stacking_context(
&self,
&mut self,
fragment: &ArcRefCell<Fragment>,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
@ -1025,7 +1061,7 @@ impl BoxFragment {
}
fn build_stacking_context_tree_for_children(
&self,
&mut self,
fragment: &ArcRefCell<Fragment>,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
@ -1034,6 +1070,19 @@ impl BoxFragment {
) {
let mut new_scroll_node_id = containing_block.scroll_node_id;
let mut new_clip_chain_id = containing_block.clip_chain_id;
let mut new_scroll_frame_size = containing_block_info
.for_non_absolute_descendants
.scroll_frame_size;
if let Some(scroll_node_id) = self.build_sticky_frame_if_necessary(
display_list,
&new_scroll_node_id,
&containing_block.rect,
&new_scroll_frame_size,
) {
new_scroll_node_id = scroll_node_id;
}
if let Some(clip_chain_id) = self.build_clip_frame_if_necessary(
display_list,
&new_scroll_node_id,
@ -1067,14 +1116,17 @@ impl BoxFragment {
// We want to build the scroll frame after the background and border, because
// they shouldn't scroll with the rest of the box content.
if let Some((scroll_node_id, clip_chain_id)) = self.build_scroll_frame_if_necessary(
display_list,
&new_scroll_node_id,
&new_clip_chain_id,
&containing_block.rect,
) {
if let Some((scroll_node_id, clip_chain_id, scroll_frame_size)) = self
.build_scroll_frame_if_necessary(
display_list,
&new_scroll_node_id,
&new_clip_chain_id,
&containing_block.rect,
)
{
new_scroll_node_id = scroll_node_id;
new_clip_chain_id = clip_chain_id;
new_scroll_frame_size = Some(scroll_frame_size);
}
let padding_rect = self
@ -1086,10 +1138,18 @@ impl BoxFragment {
.to_physical(self.style.writing_mode, &containing_block.rect)
.translate(containing_block.rect.origin.to_vector());
let for_absolute_descendants =
ContainingBlock::new(&padding_rect, new_scroll_node_id, new_clip_chain_id);
let for_non_absolute_descendants =
ContainingBlock::new(&content_rect, new_scroll_node_id, new_clip_chain_id);
let for_absolute_descendants = ContainingBlock::new(
padding_rect,
new_scroll_node_id,
new_scroll_frame_size,
new_clip_chain_id,
);
let for_non_absolute_descendants = ContainingBlock::new(
content_rect,
new_scroll_node_id,
new_scroll_frame_size,
new_clip_chain_id,
);
// Create a new `ContainingBlockInfo` for descendants depending on
// whether or not this fragment establishes a containing block for
@ -1115,7 +1175,7 @@ impl BoxFragment {
};
for child in &self.children {
child.borrow().build_stacking_context_tree(
child.borrow_mut().build_stacking_context_tree(
child,
display_list,
&new_containing_block_info,
@ -1174,7 +1234,7 @@ impl BoxFragment {
parent_scroll_node_id: &ScrollTreeNodeId,
parent_clip_id: &wr::ClipChainId,
containing_block_rect: &PhysicalRect<Length>,
) -> Option<(ScrollTreeNodeId, wr::ClipChainId)> {
) -> Option<(ScrollTreeNodeId, wr::ClipChainId, LayoutSize)> {
let overflow_x = self.style.get_box().overflow_x;
let overflow_y = self.style.get_box().overflow_y;
if overflow_x == ComputedOverflow::Visible && overflow_y == ComputedOverflow::Visible {
@ -1200,17 +1260,107 @@ impl BoxFragment {
.translate(containing_block_rect.origin.to_vector())
.to_webrender();
Some(
display_list.define_scroll_frame(
parent_scroll_node_id,
parent_clip_id,
external_id,
self.scrollable_overflow(&containing_block_rect)
.to_webrender(),
padding_rect,
sensitivity,
),
)
let (scroll_tree_node_id, clip_chain_id) = display_list.define_scroll_frame(
parent_scroll_node_id,
parent_clip_id,
external_id,
self.scrollable_overflow(&containing_block_rect)
.to_webrender(),
padding_rect,
sensitivity,
);
Some((scroll_tree_node_id, clip_chain_id, padding_rect.size))
}
fn build_sticky_frame_if_necessary(
&mut self,
display_list: &mut DisplayList,
parent_scroll_node_id: &ScrollTreeNodeId,
containing_block_rect: &PhysicalRect<Length>,
scroll_frame_size: &Option<LayoutSize>,
) -> Option<ScrollTreeNodeId> {
if self.style.get_box().position != ComputedPosition::Sticky {
return None;
}
let scroll_frame_size_for_resolve = match scroll_frame_size {
Some(size) => size,
None => {
// This is a direct descendant of a reference frame.
&display_list.compositor_info.viewport_size
},
};
// Percentages sticky positions offsets are resovled against the size of the
// nearest scroll frame instead of the containing block like for other types
// of positioning.
let position = self.style.get_position();
let offsets = PhysicalSides::new(
position
.top
.map(|v| v.resolve(Length::new(scroll_frame_size_for_resolve.height))),
position
.right
.map(|v| v.resolve(Length::new(scroll_frame_size_for_resolve.width))),
position
.bottom
.map(|v| v.resolve(Length::new(scroll_frame_size_for_resolve.height))),
position
.left
.map(|v| v.resolve(Length::new(scroll_frame_size_for_resolve.width))),
);
self.resolved_sticky_insets = Some(offsets);
if scroll_frame_size.is_none() {
return None;
}
if offsets.top.is_auto() &&
offsets.right.is_auto() &&
offsets.bottom.is_auto() &&
offsets.left.is_auto()
{
return None;
}
let frame_rect = self
.border_rect()
.to_physical(self.style.writing_mode, &containing_block_rect)
.translate(containing_block_rect.origin.to_vector())
.to_webrender();
// Position:sticky elements are always restricted based on the size and position of their
// containing block.
let containing_block_rect = containing_block_rect.to_webrender();
// This is the minimum negative offset and then the maximum positive offset. We just
// specify every edge, but if the corresponding margin is None, that offset has no effect.
let vertical_offset_bounds = wr::StickyOffsetBounds::new(
containing_block_rect.min_y() - frame_rect.min_y(),
containing_block_rect.max_y() - frame_rect.max_y(),
);
let horizontal_offset_bounds = wr::StickyOffsetBounds::new(
containing_block_rect.min_x() - frame_rect.min_x(),
containing_block_rect.max_x() - frame_rect.max_x(),
);
let margins = SideOffsets2D::new(
offsets.top.non_auto().map(|v| v.px()),
offsets.right.non_auto().map(|v| v.px()),
offsets.bottom.non_auto().map(|v| v.px()),
offsets.left.non_auto().map(|v| v.px()),
);
let sticky_node_id = display_list.define_sticky_frame(
parent_scroll_node_id,
frame_rect,
margins,
vertical_offset_bounds,
horizontal_offset_bounds,
);
Some(sticky_node_id)
}
/// Optionally returns the data for building a reference frame, without yet building it.
@ -1363,7 +1513,7 @@ impl AnonymousFragment {
containing_block_info.new_for_non_absolute_descendants(&new_containing_block);
for child in &self.children {
child.borrow().build_stacking_context_tree(
child.borrow_mut().build_stacking_context_tree(
child,
display_list,
&new_containing_block_info,

View file

@ -14,7 +14,8 @@ use style::Zero;
use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment};
use crate::cell::ArcRefCell;
use crate::geom::{
LogicalRect, LogicalSides, PhysicalPoint, PhysicalRect, PhysicalSides, PhysicalSize,
LengthOrAuto, LogicalRect, LogicalSides, PhysicalPoint, PhysicalRect, PhysicalSides,
PhysicalSize,
};
#[derive(Serialize)]
@ -49,6 +50,11 @@ pub(crate) struct BoxFragment {
/// Whether or not this box was overconstrained in the given dimension.
overconstrained: PhysicalSize<bool>,
/// The resolved box insets if this box is `position: sticky`. These are calculated
/// during stacking context tree construction because they rely on the size of the
/// scroll container.
pub(crate) resolved_sticky_insets: Option<PhysicalSides<LengthOrAuto>>,
}
impl BoxFragment {
@ -121,6 +127,7 @@ impl BoxFragment {
block_margins_collapsed_with_children,
scrollable_overflow_from_children,
overconstrained,
resolved_sticky_insets: None,
}
}
@ -217,7 +224,7 @@ impl BoxFragment {
pub(crate) fn calculate_resolved_insets_if_positioned(
&self,
containing_block: &PhysicalRect<CSSPixelLength>,
) -> PhysicalSides<CSSPixelLength> {
) -> PhysicalSides<LengthOrAuto> {
let position = self.style.get_box().position;
debug_assert_ne!(
position,
@ -230,6 +237,19 @@ impl BoxFragment {
.content_rect
.to_physical(self.style.writing_mode, &containing_block);
if let Some(resolved_sticky_insets) = self.resolved_sticky_insets {
return resolved_sticky_insets;
}
let convert_to_length_or_auto = |sides: PhysicalSides<Length>| {
PhysicalSides::new(
LengthOrAuto::LengthPercentage(sides.top),
LengthOrAuto::LengthPercentage(sides.right),
LengthOrAuto::LengthPercentage(sides.bottom),
LengthOrAuto::LengthPercentage(sides.left),
)
};
// "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
@ -255,14 +275,12 @@ impl BoxFragment {
};
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);
return convert_to_length_or_auto(PhysicalSides::new(top, right, bottom, left));
}
// TODO(servo#30570) revert to debug_assert!() once underlying bug is fixed
#[cfg(debug_assertions)]
if !(position == ComputedPosition::Fixed || position == ComputedPosition::Absolute) {
log::warn!("debug assertion failed! Got unknown position.");
}
debug_assert!(
position == ComputedPosition::Fixed || position == ComputedPosition::Absolute
);
let resolve = |value: &LengthPercentageOrAuto, container_length| {
value
@ -287,6 +305,6 @@ impl BoxFragment {
(content_rect.origin.x, cb_width - content_rect.max_x())
};
PhysicalSides::new(top, right, bottom, left)
convert_to_length_or_auto(PhysicalSides::new(top, right, bottom, left))
}
}

View file

@ -1218,7 +1218,7 @@ impl LayoutThread {
}
}
if !reflow_goal.needs_display() {
if !reflow_goal.needs_display_list() {
// Defer the paint step until the next ForDisplay.
//
// We need to tell the document about this so it doesn't
@ -1280,8 +1280,10 @@ impl LayoutThread {
self.paint_time_metrics
.maybe_observe_paint_time(self, epoch, is_contentful);
self.webrender_api
.send_display_list(display_list.compositor_info, display_list.wr.finalize().1);
if reflow_goal.needs_display() {
self.webrender_api
.send_display_list(display_list.compositor_info, display_list.wr.finalize().1);
}
self.update_iframe_sizes(iframe_sizes);

View file

@ -136,18 +136,18 @@ impl ReflowGoal {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations | ReflowGoal::UpdateScrollNode(_) => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match *querymsg {
QueryMsg::NodesFromPointQuery(..) |
QueryMsg::TextIndexQuery(..) |
QueryMsg::ElementInnerTextQuery(_) |
QueryMsg::InnerWindowDimensionsQuery(_) |
QueryMsg::ElementInnerTextQuery(_) => true,
QueryMsg::NodesFromPointQuery(..) |
QueryMsg::ResolvedStyleQuery(..) |
QueryMsg::TextIndexQuery(..) => true,
QueryMsg::ClientRectQuery(_) |
QueryMsg::ContentBoxQuery(_) |
QueryMsg::ContentBoxesQuery(_) |
QueryMsg::ClientRectQuery(_) |
QueryMsg::ScrollingAreaQuery(_) |
QueryMsg::NodeScrollIdQuery(_) |
QueryMsg::ResolvedStyleQuery(..) |
QueryMsg::ResolvedFontStyleQuery(..) |
QueryMsg::OffsetParentQuery(_) |
QueryMsg::ResolvedFontStyleQuery(..) |
QueryMsg::ScrollingAreaQuery(_) |
QueryMsg::StyleQuery => false,
},
}

View file

@ -27,6 +27,7 @@ use style_traits::ParseError;
ToResolvedValue,
ToShmem,
)]
#[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
#[repr(C, u8)]
pub enum GenericLengthPercentageOrAuto<LengthPercent> {
LengthPercentage(LengthPercent),

View file

@ -1,24 +0,0 @@
[inheritance.html]
[Property top has initial value auto]
expected: FAIL
[Property top does not inherit]
expected: FAIL
[Property right has initial value auto]
expected: FAIL
[Property right does not inherit]
expected: FAIL
[Property bottom has initial value auto]
expected: FAIL
[Property bottom does not inherit]
expected: FAIL
[Property left has initial value auto]
expected: FAIL
[Property left does not inherit]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-bottom-002.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-bottom-003.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-contained-by-display-table.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-escape-scroller-004.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-fixed-ancestor-002.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-fixed-ancestor-003.html]
expected: FAIL

View file

@ -1,2 +1,2 @@
[position-sticky-flexbox.html]
expected: FAIL
expected: TIMEOUT

View file

@ -0,0 +1,2 @@
[position-sticky-fractional-offset.html]
expected: FAIL

View file

@ -1,2 +1,2 @@
[position-sticky-grid.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-inline.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +0,0 @@
[position-sticky-nested-table.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-nested-thead-th.html]
expected: FAIL

View file

@ -1,2 +1,2 @@
[position-sticky-rendering.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +0,0 @@
[position-sticky-right-002.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-right-003.html]
expected: FAIL

View file

@ -1,2 +0,0 @@
[position-sticky-scroll-with-clip-and-abspos.html]
expected: FAIL

View file

@ -0,0 +1,2 @@
[position-sticky-stacking-context.html]
expected: TIMEOUT

View file

@ -1,2 +0,0 @@
[position-sticky-table-parts.html]
expected: FAIL

View file

@ -1,2 +1,2 @@
[position-sticky-table-td-left.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-td-right.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-tfoot-bottom.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-th-left.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-th-right.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-thead-top.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-tr-bottom.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-table-tr-top.html]
expected: FAIL
expected: TIMEOUT

View file

@ -1,2 +1,2 @@
[position-sticky-writing-modes.html]
expected: FAIL
expected: TIMEOUT

View file

@ -214,543 +214,3 @@
[vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL

View file

@ -214,543 +214,3 @@
[vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
expected: FAIL

View file

@ -1,4 +0,0 @@
[getComputedStyle-sticky-pos-percent.html]
[Sticky element's top property percentage value should be resolved against the div with overflow: hidden]
expected: FAIL