Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 20:50:07 +01:00
Code Issues Projects Releases Packages Wiki Activity

Stop skipping css-logical tests in layout-2020

Browse source
This commit is contained in:
Oriol Brufau 2023-05-30 16:26:52 +02:00
parent 43ebf6c82c
commit c1a9ff033a
53 changed files with 2019 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
tests/wpt/include-layout-2020.ini
View file

@ -22,6 +22,8 @@ skip: true
skip: false
[css-flexbox]
skip: false
[css-logical]
skip: false
[css-position]
skip: false
[css-text-decor]

75
tests/wpt/metadata-layout-2020/css/css-logical/animation-001.html.ini Normal file
View file

@ -0,0 +1,75 @@
[animation-001.html]
[Logical properties can be animated using object notation]
expected: FAIL
[Logical properties can be animated using array notation]
expected: FAIL
[Logical properties are NOT stored as physical properties]
expected: FAIL
[Logical properties in animations respect the writing-mode]
expected: FAIL
[Logical properties in animations respect the direction]
expected: FAIL
[Physical properties win over logical properties in object notation]
expected: FAIL
[Physical properties win over logical properties in array notation]
expected: FAIL
[Physical properties with variables win over logical properties]
expected: FAIL
[Logical shorthands follow the usual prioritization based on number of component longhands]
expected: FAIL
[Physical longhands win over logical shorthands]
expected: FAIL
[Logical longhands win over physical shorthands]
expected: FAIL
[Physical shorthands win over logical shorthands]
expected: FAIL
[Physical shorthands using variables win over logical shorthands]
expected: FAIL
[Physical properties and logical properties can be mixed]
expected: FAIL
[Physical shorthands and logical shorthands can be mixed]
expected: FAIL
[Physical properties win over logical properties even when some keyframes only have logical properties]
expected: FAIL
[Animations update when the writing-mode is changed]
expected: FAIL
[Filling animations update when the writing-mode is changed]
expected: FAIL
[Animations with implicit from values update when the writing-mode is changed]
expected: FAIL
[Animations with overlapping physical and logical properties update when the writing-mode is changed]
expected: FAIL
[Animations update when the writing-mode is changed through a CSS variable]
expected: FAIL
[Animations update when the direction is changed]
expected: FAIL
[Logical shorthand with variable references animates correctly]
expected: FAIL
[writing-mode is not animatable]
expected: FAIL
[direction is not animatable]
expected: FAIL

33
tests/wpt/metadata-layout-2020/css/css-logical/animation-002.html.ini Normal file
View file

@ -0,0 +1,33 @@
[animation-002.html]
[Logical properties in animations respect the writing-mode]
expected: FAIL
[Logical properties in animations respect the direction]
expected: FAIL
[Logical properties are able to override physical properties in @keyframes declaration blocks]
expected: FAIL
[Declaration order is respected amongst logical properties within @keyframes declaration blocks]
expected: FAIL
[Animations update when the writing-mode is changed]
expected: FAIL
[Filling animations update when the writing-mode is changed]
expected: FAIL
[The number of interpolating properties can be increased when the writing-mode is changed]
expected: FAIL
[The number of interpolating properties can be decreased when the writing-mode is changed]
expected: FAIL
[Animations update when the writing-mode is changed through a CSS variable]
expected: FAIL
[Logical shorthand with variable references animates correctly]
expected: FAIL
[Animations update when the direction is changed]
expected: FAIL

3
tests/wpt/metadata-layout-2020/css/css-logical/animation-003.tentative.html.ini Normal file
View file

@ -0,0 +1,3 @@
[animation-003.tentative.html]
[Logical properties are represented as physical properties in keyframes]
expected: FAIL

30
tests/wpt/metadata-layout-2020/css/css-logical/animation-004.html.ini Normal file
View file

@ -0,0 +1,30 @@
[animation-004.html]
[Logical properties in transitions respect the writing-mode]
expected: FAIL
[Logical properties in transitions respect the direction]
expected: FAIL
[Transitions update when the writing-mode is changed]
expected: FAIL
[Filling transitions update when the writing-mode is changed]
expected: FAIL
[The number of interpolating properties can be increased when the writing-mode is changed]
expected: FAIL
[The number of interpolating properties can be decreased when the writing-mode is changed]
expected: FAIL
[Transitions update when the writing-mode is changed through a CSS variable]
expected: FAIL
[Transitions update when the direction is changed]
expected: FAIL
[Transitions from logical to physical update when the direction is changed]
expected: FAIL
[Transitions from physical to logical update when the direction is changed]
expected: FAIL

84
tests/wpt/metadata-layout-2020/css/css-logical/animations/caption-side-no-interpolation.html.ini Normal file
View file

@ -0,0 +1,84 @@
[caption-side-no-interpolation.html]
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (-0.3) should be [initial\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (0) should be [initial\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (0.3) should be [initial\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (0.5) should be [bottom\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (0.6) should be [bottom\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (1) should be [bottom\]]
expected: FAIL
[CSS Transitions: property <caption-side> from [initial\] to [bottom\] at (1.5) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (-0.3) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (0) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (0.3) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (0.5) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (0.6) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (1) should be [bottom\]]
expected: FAIL
[CSS Transitions with transition: all: property <caption-side> from [initial\] to [bottom\] at (1.5) should be [bottom\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (-0.3) should be [initial\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (0) should be [initial\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (0.3) should be [initial\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (0.5) should be [bottom\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (0.6) should be [bottom\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (1) should be [bottom\]]
expected: FAIL
[CSS Animations: property <caption-side> from [initial\] to [bottom\] at (1.5) should be [bottom\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (-0.3) should be [initial\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (0) should be [initial\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (0.3) should be [initial\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (0.5) should be [bottom\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (0.6) should be [bottom\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (1) should be [bottom\]]
expected: FAIL
[Web Animations: property <caption-side> from [initial\] to [bottom\] at (1.5) should be [bottom\]]
expected: FAIL

84
tests/wpt/metadata-layout-2020/css/css-logical/animations/float-interpolation.html.ini Normal file
View file

@ -0,0 +1,84 @@
[float-interpolation.html]
[CSS Transitions: property <float> from [left\] to [right\] at (-0.3) should be [left\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (0) should be [left\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (0.3) should be [left\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (0.5) should be [right\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (0.6) should be [right\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (1) should be [right\]]
expected: FAIL
[CSS Transitions: property <float> from [left\] to [right\] at (1.5) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (-0.3) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (0) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (0.3) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (0.5) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (0.6) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (1) should be [right\]]
expected: FAIL
[CSS Transitions with transition: all: property <float> from [left\] to [right\] at (1.5) should be [right\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (-0.3) should be [left\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (0) should be [left\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (0.3) should be [left\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (0.5) should be [right\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (0.6) should be [right\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (1) should be [right\]]
expected: FAIL
[CSS Animations: property <float> from [left\] to [right\] at (1.5) should be [right\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (-0.3) should be [left\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (0) should be [left\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (0.3) should be [left\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (0.5) should be [right\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (0.6) should be [right\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (1) should be [right\]]
expected: FAIL
[Web Animations: property <float> from [left\] to [right\] at (1.5) should be [right\]]
expected: FAIL

90
tests/wpt/metadata-layout-2020/css/css-logical/getComputedStyle-listing.html.ini Normal file
View file

@ -0,0 +1,90 @@
[getComputedStyle-listing.html]
[border-block-end-color]
expected: FAIL
[border-block-end-style]
expected: FAIL
[border-block-end-width]
expected: FAIL
[border-block-start-color]
expected: FAIL
[border-block-start-style]
expected: FAIL
[border-block-start-width]
expected: FAIL
[border-inline-end-color]
expected: FAIL
[border-inline-end-style]
expected: FAIL
[border-inline-end-width]
expected: FAIL
[border-inline-start-color]
expected: FAIL
[border-inline-start-style]
expected: FAIL
[border-inline-start-width]
expected: FAIL
[inset-block-start]
expected: FAIL
[inset-block-end]
expected: FAIL
[inset-inline-start]
expected: FAIL
[inset-inline-end]
expected: FAIL
[margin-block-start]
expected: FAIL
[margin-block-end]
expected: FAIL
[margin-inline-start]
expected: FAIL
[margin-inline-end]
expected: FAIL
[padding-block-start]
expected: FAIL
[padding-block-end]
expected: FAIL
[padding-inline-start]
expected: FAIL
[padding-inline-end]
expected: FAIL
[block-size]
expected: FAIL
[inline-size]
expected: FAIL
[max-block-size]
expected: FAIL
[max-inline-size]
expected: FAIL
[min-block-size]
expected: FAIL
[min-inline-size]
expected: FAIL

9
tests/wpt/metadata-layout-2020/css/css-logical/inheritance.html.ini Normal file
View file

@ -0,0 +1,9 @@
[inheritance.html]
[Property margin-inline-end does not inherit]
expected: FAIL
[Property min-block-size has initial value 0px]
expected: FAIL
[Property min-inline-size has initial value 0px]
expected: FAIL

117
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-color.html.ini Normal file
View file

@ -0,0 +1,117 @@
[logical-box-border-color.html]
[Test that border-inline-color shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-block-color shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-color shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-color properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-color properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

81
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-radius.html.ini Normal file
View file

@ -0,0 +1,81 @@
[logical-box-border-radius.html]
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-radius properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-radius properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

129
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-shorthands.html.ini Normal file
View file

@ -0,0 +1,129 @@
[logical-box-border-shorthands.html]
[Test that border-inline shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-block shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: ltr; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: ltr; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

117
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-style.html.ini Normal file
View file

@ -0,0 +1,117 @@
[logical-box-border-style.html]
[Test that border-inline-style shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-block-style shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-style shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-style properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-style properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

117
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-width.html.ini Normal file
View file

@ -0,0 +1,117 @@
[logical-box-border-width.html]
[Test that border-inline-width shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-block-width shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that border-width shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical border-*-width properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that border-*-width properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

120
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-inset.html.ini Normal file
View file

@ -0,0 +1,120 @@
[logical-box-inset.html]
[Test that inset-inline shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that inset-block shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that inset shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: ltr; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical inset-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that inset-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

117
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-margin.html.ini Normal file
View file

@ -0,0 +1,117 @@
[logical-box-margin.html]
[Test that margin-inline shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that margin-block shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that margin shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical margin-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that margin-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

117
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-padding.html.ini Normal file
View file

@ -0,0 +1,117 @@
[logical-box-padding.html]
[Test that padding-inline shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that padding-block shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that padding shorthand sets longhands and serializes correctly.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: horizontal-tb; direction: rtl; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical padding-* properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* shorthands set the computed value of both logical and physical longhands, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that padding-* properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

216
tests/wpt/metadata-layout-2020/css/css-logical/logical-box-size.html.ini Normal file
View file

@ -0,0 +1,216 @@
[logical-box-size.html]
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor order of appearance when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical max sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that max sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: rtl; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: rtl; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-rl; direction: ltr; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-rl; direction: ltr; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: rtl; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: ltr; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: vertical-lr; direction: ltr; '.]
expected: FAIL
[Test that logical min sizing properties share computed values with their physical associates, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: 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; '.]
expected: FAIL
[Test that min sizing properties honor selector specificty when both logical and physical associates are declared, with 'writing-mode: sideways-lr; direction: rtl; '.]
expected: FAIL

2
tests/wpt/metadata-layout-2020/css/css-logical/logical-values-float-clear-3.html.ini Normal file
View file

@ -0,0 +1,2 @@
[logical-values-float-clear-3.html]
expected: FAIL

2
tests/wpt/metadata-layout-2020/css/css-logical/logical-values-float-clear-4.html.ini Normal file
View file

@ -0,0 +1,2 @@
[logical-values-float-clear-4.html]
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/logical-values-float-clear.html.ini Normal file
View file

@ -0,0 +1,12 @@
[logical-values-float-clear.html]
[Test that 'clear: inline-start' is supported.]
expected: FAIL
[Test that 'clear: inline-end' is supported.]
expected: FAIL
[Test that 'float: inline-start' is supported.]
expected: FAIL
[Test that 'float: inline-end' is supported.]
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/logical-values-resize.html.ini Normal file
View file

@ -0,0 +1,6 @@
[logical-values-resize.html]
[Test that 'resize: block' is supported.]
expected: FAIL
[Test that 'resize: inline' is supported.]
expected: FAIL

21
tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-block-size-vlr.html.ini Normal file
View file

@ -0,0 +1,21 @@
[logicalprops-block-size-vlr.html]
[.block 1]
expected: FAIL
[.block 2]
expected: FAIL
[.block 3]
expected: FAIL
[.override 4]
expected: FAIL
[.override 5]
expected: FAIL
[.tablecell 6]
expected: FAIL
[.tablecell 8]
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-block-size.html.ini Normal file
View file

@ -0,0 +1,6 @@
[logicalprops-block-size.html]
[.tablecell 6]
expected: FAIL
[.tablecell 8]
expected: FAIL

18
tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-inline-size-vlr.html.ini Normal file
View file

@ -0,0 +1,18 @@
[logicalprops-inline-size-vlr.html]
[.block 1]
expected: FAIL
[.block 2]
expected: FAIL
[.block 3]
expected: FAIL
[.override 4]
expected: FAIL
[.override 5]
expected: FAIL
[.tablecell 6]
expected: FAIL

15
tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-with-deferred-writing-mode.html.ini Normal file
View file

@ -0,0 +1,15 @@
[logicalprops-with-deferred-writing-mode.html]
[Writing mode with variable]
expected: FAIL
[Writing mode with nested variables]
expected: FAIL
[Writing mode with 'inherit']
expected: FAIL
[Writing mode with 'revert']
expected: FAIL
[Writing mode with 'revert-layer']
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-with-variables.html.ini Normal file
View file

@ -0,0 +1,12 @@
[logicalprops-with-variables.html]
[Logical longhands with variables - margin-inline]
expected: FAIL
[Logical shorthand with 1 variable - margin-inline]
expected: FAIL
[Logical shorthand with 2 variables - margin-inline]
expected: FAIL
[Logical shorthand with 1 variable and 1 length - margin-inline]
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/block-size-computed.html.ini Normal file
View file

@ -0,0 +1,6 @@
[block-size-computed.html]
[Property block-size value 'min-content']
expected: FAIL
[Property block-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/block-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[block-size-valid.html]
[e.style['block-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['block-size'\] = "max-content" should set the property value]
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-block-color-computed.html.ini Normal file
View file

@ -0,0 +1,12 @@
[border-block-color-computed.html]
[Property border-block-color value 'rgb(34, 51, 68)']
expected: FAIL
[Property border-block-color value 'transparent rgb(2, 3, 4)']
expected: FAIL
[Property border-block-color value 'rgb(2, 3, 4) rgb(2, 3, 4)']
expected: FAIL
[Property border-block-color value 'currentcolor lime']
expected: FAIL

9
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-block-style-computed.html.ini Normal file
View file

@ -0,0 +1,9 @@
[border-block-style-computed.html]
[Property border-block-style value 'dotted']
expected: FAIL
[Property border-block-style value 'double groove']
expected: FAIL
[Property border-block-style value 'hidden hidden']
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-block-width-computed.html.ini Normal file
View file

@ -0,0 +1,12 @@
[border-block-width-computed.html]
[Property border-block-width value '10px']
expected: FAIL
[Property border-block-width value '10px 20px']
expected: FAIL
[Property border-block-width value '10px 10px']
expected: FAIL
[width is zero if the border block style is none or hidden]
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-inline-color-computed.html.ini Normal file
View file

@ -0,0 +1,12 @@
[border-inline-color-computed.html]
[Property border-inline-color value 'rgb(34, 51, 68)']
expected: FAIL
[Property border-inline-color value 'transparent rgb(2, 3, 4)']
expected: FAIL
[Property border-inline-color value 'rgb(2, 3, 4) rgb(2, 3, 4)']
expected: FAIL
[Property border-inline-color value 'currentcolor lime']
expected: FAIL

9
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-inline-style-computed.html.ini Normal file
View file

@ -0,0 +1,9 @@
[border-inline-style-computed.html]
[Property border-inline-style value 'dotted']
expected: FAIL
[Property border-inline-style value 'double groove']
expected: FAIL
[Property border-inline-style value 'hidden hidden']
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-logical/parsing/border-inline-width-computed.html.ini Normal file
View file

@ -0,0 +1,12 @@
[border-inline-width-computed.html]
[Property border-inline-width value '10px']
expected: FAIL
[Property border-inline-width value '10px 20px']
expected: FAIL
[Property border-inline-width value '10px 10px']
expected: FAIL
[width is zero if the border block style is none or hidden]
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inline-size-computed.html.ini Normal file
View file

@ -0,0 +1,6 @@
[inline-size-computed.html]
[Property inline-size value 'min-content']
expected: FAIL
[Property inline-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inline-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[inline-size-valid.html]
[e.style['inline-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['inline-size'\] = "max-content" should set the property value]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-block-inline-computed.html.ini Normal file
View file

@ -0,0 +1,24 @@
[inset-block-inline-computed.html]
[Property inset-block value 'auto']
expected: FAIL
[Property inset-block value '-10px']
expected: FAIL
[Property inset-block value 'calc(10px - 0.5em) -20%']
expected: FAIL
[Property inset-block value 'auto auto']
expected: FAIL
[Property inset-inline value '-20%']
expected: FAIL
[Property inset-inline value 'calc(10px - 0.5em)']
expected: FAIL
[Property inset-inline value '-10px auto']
expected: FAIL
[Property inset-inline value 'auto calc(10px + 0.5em)']
expected: FAIL

36
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-block-inline-shorthand.html.ini Normal file
View file

@ -0,0 +1,36 @@
[inset-block-inline-shorthand.html]
[e.style['inset-block'\] = "10px" should set inset-block-end]
expected: FAIL
[e.style['inset-block'\] = "10px" should set inset-block-start]
expected: FAIL
[e.style['inset-block'\] = "10px" should not set unrelated longhands]
expected: FAIL
[e.style['inset-block'\] = "20% auto" should set inset-block-end]
expected: FAIL
[e.style['inset-block'\] = "20% auto" should set inset-block-start]
expected: FAIL
[e.style['inset-block'\] = "20% auto" should not set unrelated longhands]
expected: FAIL
[e.style['inset-inline'\] = "30%" should set inset-inline-end]
expected: FAIL
[e.style['inset-inline'\] = "30%" should set inset-inline-start]
expected: FAIL
[e.style['inset-inline'\] = "30%" should not set unrelated longhands]
expected: FAIL
[e.style['inset-inline'\] = "auto 40px" should set inset-inline-end]
expected: FAIL
[e.style['inset-inline'\] = "auto 40px" should set inset-inline-start]
expected: FAIL
[e.style['inset-inline'\] = "auto 40px" should not set unrelated longhands]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-block-inline-valid.html.ini Normal file
View file

@ -0,0 +1,24 @@
[inset-block-inline-valid.html]
[e.style['inset-block'\] = "auto" should set the property value]
expected: FAIL
[e.style['inset-block'\] = "-10px" should set the property value]
expected: FAIL
[e.style['inset-block'\] = "calc(10px - 0.5em) -20%" should set the property value]
expected: FAIL
[e.style['inset-block'\] = "auto auto" should set the property value]
expected: FAIL
[e.style['inset-inline'\] = "-20%" should set the property value]
expected: FAIL
[e.style['inset-inline'\] = "calc(10px - 0.5em)" should set the property value]
expected: FAIL
[e.style['inset-inline'\] = "-10px auto" should set the property value]
expected: FAIL
[e.style['inset-inline'\] = "auto calc(10px + 0.5em)" should set the property value]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-computed.html.ini Normal file
View file

@ -0,0 +1,24 @@
[inset-computed.html]
[Property inset value 'auto']
expected: FAIL
[Property inset value '-10px']
expected: FAIL
[Property inset value 'calc(10px - 0.5em) -20%']
expected: FAIL
[Property inset value 'auto auto']
expected: FAIL
[Property inset value '10px calc(10px - 0.5em) -30px']
expected: FAIL
[Property inset value 'auto auto auto']
expected: FAIL
[Property inset value '10px 20px auto -30px']
expected: FAIL
[Property inset value 'auto auto auto auto']
expected: FAIL

60
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-shorthand.html.ini Normal file
View file

@ -0,0 +1,60 @@
[inset-shorthand.html]
[e.style['inset'\] = "1px 2px 3px 4px" should set bottom]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px 4px" should set left]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px 4px" should set right]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px 4px" should set top]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px 4px" should not set unrelated longhands]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px" should set bottom]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px" should set left]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px" should set right]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px" should set top]
expected: FAIL
[e.style['inset'\] = "1px 2px 3px" should not set unrelated longhands]
expected: FAIL
[e.style['inset'\] = "1px 2px" should set bottom]
expected: FAIL
[e.style['inset'\] = "1px 2px" should set left]
expected: FAIL
[e.style['inset'\] = "1px 2px" should set right]
expected: FAIL
[e.style['inset'\] = "1px 2px" should set top]
expected: FAIL
[e.style['inset'\] = "1px 2px" should not set unrelated longhands]
expected: FAIL
[e.style['inset'\] = "1px" should set bottom]
expected: FAIL
[e.style['inset'\] = "1px" should set left]
expected: FAIL
[e.style['inset'\] = "1px" should set right]
expected: FAIL
[e.style['inset'\] = "1px" should set top]
expected: FAIL
[e.style['inset'\] = "1px" should not set unrelated longhands]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-valid.html.ini Normal file
View file

@ -0,0 +1,24 @@
[inset-valid.html]
[e.style['inset'\] = "auto" should set the property value]
expected: FAIL
[e.style['inset'\] = "-10px" should set the property value]
expected: FAIL
[e.style['inset'\] = "calc(-0.5em + 10px) -20%" should set the property value]
expected: FAIL
[e.style['inset'\] = "auto auto" should set the property value]
expected: FAIL
[e.style['inset'\] = "10px calc(-0.5em + 10px) -30px" should set the property value]
expected: FAIL
[e.style['inset'\] = "auto auto auto" should set the property value]
expected: FAIL
[e.style['inset'\] = "10px calc(-0.5em + 10px) auto -30px" should set the property value]
expected: FAIL
[e.style['inset'\] = "auto auto auto auto" should set the property value]
expected: FAIL

21
tests/wpt/metadata-layout-2020/css/css-logical/parsing/margin-block-inline-computed.html.ini Normal file
View file

@ -0,0 +1,21 @@
[margin-block-inline-computed.html]
[Property margin-block-end value '10%']
expected: FAIL
[Property margin-block-start value 'calc(10% + 40px)']
expected: FAIL
[Property margin-inline-end value 'calc(10% + 40px)']
expected: FAIL
[Property margin-block value '10px']
expected: FAIL
[Property margin-block value '10px 20px']
expected: FAIL
[Property margin-inline value '30px']
expected: FAIL
[Property margin-inline value '30px 40px']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/max-block-size-computed.html.ini Normal file
View file

@ -0,0 +1,6 @@
[max-block-size-computed.html]
[Property max-block-size value 'min-content']
expected: FAIL
[Property max-block-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/max-block-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[max-block-size-valid.html]
[e.style['max-block-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['max-block-size'\] = "max-content" should set the property value]
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/max-inline-size-computed.html.ini Normal file
View file

@ -0,0 +1,6 @@
[max-inline-size-computed.html]
[Property max-inline-size value 'min-content']
expected: FAIL
[Property max-inline-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/max-inline-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[max-inline-size-valid.html]
[e.style['max-inline-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['max-inline-size'\] = "max-content" should set the property value]
expected: FAIL

9
tests/wpt/metadata-layout-2020/css/css-logical/parsing/min-block-size-computed.html.ini Normal file
View file

@ -0,0 +1,9 @@
[min-block-size-computed.html]
[Property min-block-size value 'auto']
expected: FAIL
[Property min-block-size value 'min-content']
expected: FAIL
[Property min-block-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/min-block-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[min-block-size-valid.html]
[e.style['min-block-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['min-block-size'\] = "max-content" should set the property value]
expected: FAIL

9
tests/wpt/metadata-layout-2020/css/css-logical/parsing/min-inline-size-computed.html.ini Normal file
View file

@ -0,0 +1,9 @@
[min-inline-size-computed.html]
[Property min-inline-size value 'auto']
expected: FAIL
[Property min-inline-size value 'min-content']
expected: FAIL
[Property min-inline-size value 'max-content']
expected: FAIL

6
tests/wpt/metadata-layout-2020/css/css-logical/parsing/min-inline-size-valid.html.ini Normal file
View file

@ -0,0 +1,6 @@
[min-inline-size-valid.html]
[e.style['min-inline-size'\] = "min-content" should set the property value]
expected: FAIL
[e.style['min-inline-size'\] = "max-content" should set the property value]
expected: FAIL

27
tests/wpt/metadata-layout-2020/css/css-logical/parsing/padding-block-inline-computed.html.ini Normal file
View file

@ -0,0 +1,27 @@
[padding-block-inline-computed.html]
[Property padding-block-end value '10%']
expected: FAIL
[Property padding-block-start value 'calc(10% + 40px)']
expected: FAIL
[Property padding-block-end value 'calc(10% - 40px)']
expected: FAIL
[Property padding-inline-start value 'calc(10% - 40px)']
expected: FAIL
[Property padding-inline-end value 'calc(10% + 40px)']
expected: FAIL
[Property padding-block value '10px']
expected: FAIL
[Property padding-block value '10px 20px']
expected: FAIL
[Property padding-inline value '30px']
expected: FAIL
[Property padding-inline value '30px 40px']
expected: FAIL