Stop skipping css-logical tests in layout-2020

tests/wpt/include-layout-2020.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/animation-001.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/animation-002.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/animation-003.tentative.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/animation-004.html.ini

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

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

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

tests/wpt/metadata-layout-2020/css/css-logical/animations/float-interpolation.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/getComputedStyle-listing.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/inheritance.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-color.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-radius.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-shorthands.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-style.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-border-width.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-inset.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-margin.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-padding.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-box-size.html.ini

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

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

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

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

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-values-float-clear.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/logical-values-resize.html.ini

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

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

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

tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-block-size.html.ini

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

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

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

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

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

tests/wpt/metadata-layout-2020/css/css-logical/logicalprops-with-variables.html.ini

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-computed.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-shorthand.html.ini

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

tests/wpt/metadata-layout-2020/css/css-logical/parsing/inset-valid.html.ini

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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