mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-07-31 13:19:05 +00:00
LibWeb: Respect writing-mode and direction when mapping logical aliases
This commit is contained in:
Callum Law
Sam Atkins
parent
34a52baeed
commit
b0cdc3f03b
Notes:
github-actions[bot]
2025-06-23 14:20:27 +00:00
Author: https://github.com/Calme1709
Commit: b0cdc3f03b
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/5138
Reviewed-by: https://github.com/AtkinsSJ ✅
6 changed files with 478 additions and 249 deletions
|
|
@ -888,70 +888,303 @@ void StyleComputer::for_each_property_expanding_shorthands(PropertyID property_i
|
|||
set_longhand_property(property_id, value);
|
||||
}
|
||||
|
||||
PropertyID StyleComputer::map_logical_alias_to_physical_property_id(PropertyID property_id, LogicalAliasMappingContext)
|
||||
// https://drafts.csswg.org/css-writing-modes-4/#logical-to-physical
|
||||
PropertyID StyleComputer::map_logical_alias_to_physical_property_id(PropertyID property_id, LogicalAliasMappingContext mapping_context)
|
||||
{
|
||||
// FIXME: Honor writing-mode, direction and text-orientation.
|
||||
// FIXME: Note: The used direction depends on the computed writing-mode and text-orientation: in vertical writing
|
||||
// modes, a text-orientation value of upright forces the used direction to ltr.
|
||||
auto used_direction = mapping_context.direction;
|
||||
switch (property_id) {
|
||||
case PropertyID::BlockSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::Height;
|
||||
case PropertyID::BorderBlockEndColor:
|
||||
return PropertyID::BorderBottomColor;
|
||||
case PropertyID::BorderBlockEndStyle:
|
||||
return PropertyID::BorderBottomStyle;
|
||||
case PropertyID::BorderBlockEndWidth:
|
||||
return PropertyID::BorderBottomWidth;
|
||||
case PropertyID::BorderBlockStartColor:
|
||||
return PropertyID::BorderTopColor;
|
||||
case PropertyID::BorderBlockStartStyle:
|
||||
return PropertyID::BorderTopStyle;
|
||||
case PropertyID::BorderBlockStartWidth:
|
||||
return PropertyID::BorderTopWidth;
|
||||
case PropertyID::BorderInlineStartColor:
|
||||
return PropertyID::BorderLeftColor;
|
||||
case PropertyID::BorderInlineStartStyle:
|
||||
return PropertyID::BorderLeftStyle;
|
||||
case PropertyID::BorderInlineStartWidth:
|
||||
return PropertyID::BorderLeftWidth;
|
||||
case PropertyID::BorderInlineEndColor:
|
||||
return PropertyID::BorderRightColor;
|
||||
case PropertyID::BorderInlineEndStyle:
|
||||
return PropertyID::BorderRightStyle;
|
||||
case PropertyID::BorderInlineEndWidth:
|
||||
return PropertyID::BorderRightWidth;
|
||||
case PropertyID::MarginBlockStart:
|
||||
return PropertyID::MarginTop;
|
||||
case PropertyID::MarginBlockEnd:
|
||||
return PropertyID::MarginBottom;
|
||||
case PropertyID::MarginInlineStart:
|
||||
return PropertyID::MarginLeft;
|
||||
case PropertyID::MarginInlineEnd:
|
||||
return PropertyID::MarginRight;
|
||||
case PropertyID::MaxBlockSize:
|
||||
return PropertyID::MaxHeight;
|
||||
case PropertyID::MaxInlineSize:
|
||||
return PropertyID::MaxWidth;
|
||||
case PropertyID::MinBlockSize:
|
||||
return PropertyID::MinHeight;
|
||||
case PropertyID::MinInlineSize:
|
||||
return PropertyID::MinWidth;
|
||||
case PropertyID::PaddingBlockStart:
|
||||
return PropertyID::PaddingTop;
|
||||
case PropertyID::PaddingBlockEnd:
|
||||
return PropertyID::PaddingBottom;
|
||||
case PropertyID::PaddingInlineStart:
|
||||
return PropertyID::PaddingLeft;
|
||||
case PropertyID::PaddingInlineEnd:
|
||||
return PropertyID::PaddingRight;
|
||||
case PropertyID::InlineSize:
|
||||
return PropertyID::Width;
|
||||
case PropertyID::BorderBlockEndColor:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderBottomColor;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderLeftColor;
|
||||
return PropertyID::BorderRightColor;
|
||||
case PropertyID::BorderBlockEndStyle:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderBottomStyle;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderLeftStyle;
|
||||
return PropertyID::BorderRightStyle;
|
||||
case PropertyID::BorderBlockEndWidth:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderBottomWidth;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderLeftWidth;
|
||||
return PropertyID::BorderRightWidth;
|
||||
case PropertyID::BorderBlockStartColor:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderTopColor;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderRightColor;
|
||||
return PropertyID::BorderLeftColor;
|
||||
case PropertyID::BorderBlockStartStyle:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderTopStyle;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderRightStyle;
|
||||
return PropertyID::BorderLeftStyle;
|
||||
case PropertyID::BorderBlockStartWidth:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::BorderTopWidth;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::BorderRightWidth;
|
||||
return PropertyID::BorderLeftWidth;
|
||||
case PropertyID::BorderInlineStartColor:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderLeftColor;
|
||||
return PropertyID::BorderRightColor;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopColor;
|
||||
return PropertyID::BorderBottomColor;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomColor;
|
||||
return PropertyID::BorderTopColor;
|
||||
case PropertyID::BorderInlineStartStyle:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderLeftStyle;
|
||||
return PropertyID::BorderRightStyle;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopStyle;
|
||||
return PropertyID::BorderBottomStyle;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomStyle;
|
||||
return PropertyID::BorderTopStyle;
|
||||
|
||||
case PropertyID::BorderInlineStartWidth:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderLeftWidth;
|
||||
return PropertyID::BorderRightWidth;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopWidth;
|
||||
return PropertyID::BorderBottomWidth;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomWidth;
|
||||
return PropertyID::BorderTopWidth;
|
||||
case PropertyID::BorderInlineEndColor:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderRightColor;
|
||||
return PropertyID::BorderLeftColor;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomColor;
|
||||
return PropertyID::BorderTopColor;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopColor;
|
||||
return PropertyID::BorderBottomColor;
|
||||
case PropertyID::BorderInlineEndStyle:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderRightStyle;
|
||||
return PropertyID::BorderLeftStyle;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomStyle;
|
||||
return PropertyID::BorderTopStyle;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopStyle;
|
||||
return PropertyID::BorderBottomStyle;
|
||||
case PropertyID::BorderInlineEndWidth:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderRightWidth;
|
||||
return PropertyID::BorderLeftWidth;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderBottomWidth;
|
||||
return PropertyID::BorderTopWidth;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::BorderTopWidth;
|
||||
return PropertyID::BorderBottomWidth;
|
||||
|
||||
case PropertyID::MarginBlockStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MarginTop;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::MarginRight;
|
||||
return PropertyID::MarginLeft;
|
||||
case PropertyID::MarginBlockEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MarginBottom;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::MarginLeft;
|
||||
return PropertyID::MarginRight;
|
||||
case PropertyID::MarginInlineStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginLeft;
|
||||
return PropertyID::MarginRight;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginTop;
|
||||
return PropertyID::MarginBottom;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginBottom;
|
||||
return PropertyID::MarginTop;
|
||||
case PropertyID::MarginInlineEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginRight;
|
||||
return PropertyID::MarginLeft;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginBottom;
|
||||
return PropertyID::MarginTop;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::MarginTop;
|
||||
return PropertyID::MarginBottom;
|
||||
case PropertyID::MaxBlockSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MaxHeight;
|
||||
return PropertyID::MaxWidth;
|
||||
case PropertyID::MaxInlineSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MaxWidth;
|
||||
return PropertyID::MaxHeight;
|
||||
case PropertyID::MinBlockSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MinHeight;
|
||||
return PropertyID::MinWidth;
|
||||
case PropertyID::MinInlineSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::MinWidth;
|
||||
return PropertyID::MinHeight;
|
||||
case PropertyID::PaddingBlockStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::PaddingTop;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::PaddingRight;
|
||||
return PropertyID::PaddingLeft;
|
||||
case PropertyID::PaddingBlockEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::PaddingBottom;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::PaddingLeft;
|
||||
return PropertyID::PaddingRight;
|
||||
case PropertyID::PaddingInlineStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingLeft;
|
||||
return PropertyID::PaddingRight;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingTop;
|
||||
return PropertyID::PaddingBottom;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingBottom;
|
||||
return PropertyID::PaddingTop;
|
||||
case PropertyID::PaddingInlineEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingRight;
|
||||
return PropertyID::PaddingLeft;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingBottom;
|
||||
return PropertyID::PaddingTop;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::PaddingTop;
|
||||
return PropertyID::PaddingBottom;
|
||||
case PropertyID::InlineSize:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::Width;
|
||||
return PropertyID::Height;
|
||||
case PropertyID::InsetBlockStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::Top;
|
||||
case PropertyID::InsetBlockEnd:
|
||||
return PropertyID::Bottom;
|
||||
case PropertyID::InsetInlineStart:
|
||||
return PropertyID::Left;
|
||||
case PropertyID::InsetInlineEnd:
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::Right;
|
||||
return PropertyID::Left;
|
||||
case PropertyID::InsetBlockEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb)
|
||||
return PropertyID::Bottom;
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl))
|
||||
return PropertyID::Left;
|
||||
return PropertyID::Right;
|
||||
case PropertyID::InsetInlineStart:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Left;
|
||||
return PropertyID::Right;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Top;
|
||||
return PropertyID::Bottom;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Bottom;
|
||||
return PropertyID::Top;
|
||||
case PropertyID::InsetInlineEnd:
|
||||
if (mapping_context.writing_mode == WritingMode::HorizontalTb) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Right;
|
||||
return PropertyID::Left;
|
||||
}
|
||||
|
||||
if (first_is_one_of(mapping_context.writing_mode, WritingMode::VerticalRl, WritingMode::SidewaysRl, WritingMode::VerticalLr)) {
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Bottom;
|
||||
return PropertyID::Top;
|
||||
}
|
||||
|
||||
if (used_direction == Direction::Ltr)
|
||||
return PropertyID::Top;
|
||||
return PropertyID::Bottom;
|
||||
default:
|
||||
VERIFY(!property_is_logical_alias(property_id));
|
||||
return property_id;
|
||||
|
|
|
|||
|
|
@ -2,12 +2,12 @@ Harness status: OK
|
|||
|
||||
Found 12 tests
|
||||
|
||||
4 Pass
|
||||
8 Fail
|
||||
6 Pass
|
||||
6 Fail
|
||||
Pass .flexbox 1
|
||||
Fail .flexbox 2
|
||||
Pass .flexbox 2
|
||||
Pass .flexbox 3
|
||||
Fail .flexbox 4
|
||||
Pass .flexbox 4
|
||||
Pass .flexbox 5
|
||||
Pass .flexbox 6
|
||||
Fail .flexbox 7
|
||||
|
|
|
|||
|
|
@ -2,8 +2,7 @@ Harness status: OK
|
|||
|
||||
Found 44 tests
|
||||
|
||||
8 Pass
|
||||
36 Fail
|
||||
44 Pass
|
||||
Pass Test that logical inset-* properties are supported.
|
||||
Pass Test that inset-inline shorthand sets longhands and serializes correctly.
|
||||
Pass Test that inset-block shorthand sets longhands and serializes correctly.
|
||||
|
|
@ -12,39 +11,39 @@ Pass Test that logical inset-* properties share computed values with their physi
|
|||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
|
|
@ -2,8 +2,7 @@ Harness status: OK
|
|||
|
||||
Found 44 tests
|
||||
|
||||
8 Pass
|
||||
36 Fail
|
||||
44 Pass
|
||||
Pass Test that logical margin-* properties are supported.
|
||||
Pass Test that margin-inline shorthand sets longhands and serializes correctly.
|
||||
Pass Test that margin-block shorthand sets longhands and serializes correctly.
|
||||
|
|
@ -12,39 +11,39 @@ Pass Test that logical margin-* properties share computed values with their phys
|
|||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
|
|
@ -2,8 +2,7 @@ Harness status: OK
|
|||
|
||||
Found 44 tests
|
||||
|
||||
8 Pass
|
||||
36 Fail
|
||||
44 Pass
|
||||
Pass Test that logical padding-* properties are supported.
|
||||
Pass Test that padding-inline shorthand sets longhands and serializes correctly.
|
||||
Pass Test that padding-block shorthand sets longhands and serializes correctly.
|
||||
|
|
@ -12,39 +11,39 @@ Pass Test that logical padding-* properties share computed values with their phy
|
|||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
|
|
@ -2,8 +2,7 @@ Harness status: OK
|
|||
|
||||
Found 93 tests
|
||||
|
||||
21 Pass
|
||||
72 Fail
|
||||
93 Pass
|
||||
Pass Test that logical sizing properties are supported.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
|
|
@ -11,30 +10,30 @@ Pass Test that sizing properties honor selector specificty when both logical and
|
|||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical max sizing properties are supported.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
|
|
@ -42,30 +41,30 @@ Pass Test that max sizing properties honor selector specificty when both logical
|
|||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical min sizing properties are supported.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.
|
||||
|
|
@ -73,27 +72,27 @@ Pass Test that min sizing properties honor selector specificty when both logical
|
|||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Fail Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Fail Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.
|
||||
Pass Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Pass Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.
|
||||
Loading…
Add table
Add a link
Reference in a new issue