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

Better implement getComputedStyle() for positioned insets

Browse source 
The specification dictates quite quite idiosyncratic return values when
querying insets of positioned elements via getComputedStyle(). These
depend on whether or not the elements size was overconstrained. This
change adds a better implementation of that in preparation for returning
proper values for position: sticky.
This commit is contained in:
Martin Robinson 2023-04-28 17:17:43 +02:00
parent 4e37d07ea4
commit e167526618
26 changed files with 801 additions and 1318 deletions
Download patch file Download diff file Expand all files Collapse all files

36
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-001.html.ini
View file

@ -34,3 +34,39 @@
[.container > div 24]
expected: FAIL
[.container > div 2]
expected: FAIL
[.container > div 3]
expected: FAIL
[.container > div 4]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 14]
expected: FAIL
[.container > div 15]
expected: FAIL
[.container > div 16]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 23]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-002.html.ini
View file

@ -46,3 +46,27 @@
[.container > div 23]
expected: FAIL
[.container > div 4]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 16]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 24]
expected: FAIL

36
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-005.html.ini
View file

@ -34,3 +34,39 @@
[.container > div 24]
expected: FAIL
[.container > div 2]
expected: FAIL
[.container > div 3]
expected: FAIL
[.container > div 4]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 14]
expected: FAIL
[.container > div 15]
expected: FAIL
[.container > div 16]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 23]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-006.html.ini
View file

@ -46,3 +46,27 @@
[.container > div 23]
expected: FAIL
[.container > div 4]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 16]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 24]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-003.html.ini
View file

@ -46,3 +46,27 @@
[.container > div 23]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 17]
expected: FAIL
[.container > div 20]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 24]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-rtl-004.html.ini
View file

@ -46,3 +46,27 @@
[.container > div 23]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 17]
expected: FAIL
[.container > div 20]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 24]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-001.html.ini
View file

@ -58,3 +58,27 @@
[.container > div 28]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 24]
expected: FAIL
[.container > div 26]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-align-self-vertWM-002.html.ini
View file

@ -58,3 +58,27 @@
[.container > div 28]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 23]
expected: FAIL
[.container > div 26]
expected: FAIL

36
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-001.html.ini
View file

@ -34,3 +34,39 @@
[.container > div 24]
expected: FAIL
[.container > div 1]
expected: FAIL
[.container > div 2]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 13]
expected: FAIL
[.container > div 14]
expected: FAIL
[.container > div 17]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 23]
expected: FAIL

18
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-003.html.ini
View file

@ -52,3 +52,21 @@
[.container > div 24]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 23]
expected: FAIL

42
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-005.html.ini
View file

@ -28,3 +28,45 @@
[.container > div 22]
expected: FAIL
[.container > div 1]
expected: FAIL
[.container > div 2]
expected: FAIL
[.container > div 5]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 9]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 13]
expected: FAIL
[.container > div 14]
expected: FAIL
[.container > div 17]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 21]
expected: FAIL
[.container > div 23]
expected: FAIL
[.container > div 24]
expected: FAIL

24
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-007.html.ini
View file

@ -46,3 +46,27 @@
[.container > div 21]
expected: FAIL
[.container > div 7]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 12]
expected: FAIL
[.container > div 19]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 23]
expected: FAIL
[.container > div 24]
expected: FAIL

18
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-rtl-001.html.ini
View file

@ -52,3 +52,21 @@
[.container > div 24]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 20]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 23]
expected: FAIL

18
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/flex-abspos-staticpos-justify-content-vertWM-002.html.ini
View file

@ -52,3 +52,21 @@
[.container > div 24]
expected: FAIL
[.container > div 8]
expected: FAIL
[.container > div 10]
expected: FAIL
[.container > div 11]
expected: FAIL
[.container > div 20]
expected: FAIL
[.container > div 22]
expected: FAIL
[.container > div 23]
expected: FAIL

12
tests/wpt/metadata-layout-2020/css/css-flexbox/abspos/position-absolute-003.html.ini
View file

@ -22,3 +22,15 @@
[.rect 16]
expected: FAIL
[.rect 1]
expected: FAIL
[.rect 2]
expected: FAIL
[.rect 3]
expected: FAIL
[.rect 4]
expected: FAIL

4
tests/wpt/metadata-layout-2020/css/cssom/computed-style-005.html.ini
View file

@ -1,7 +1,3 @@
[computed-style-005.html]
[relative_computed_left_and_right]
expected: FAIL
[absolute_computed_left_and_right]
expected: FAIL

324
tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-absolute.html.ini
View file

@ -2,75 +2,18 @@
[vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -83,222 +26,90 @@
[vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -308,66 +119,27 @@
[vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -377,42 +149,21 @@
[horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
@ -422,42 +173,21 @@
[vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -467,74 +197,20 @@
[horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL

324
tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-fixed.html.ini
View file

@ -2,75 +2,18 @@
[vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -83,222 +26,90 @@
[vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -308,66 +119,27 @@
[vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -377,42 +149,21 @@
[horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
@ -422,42 +173,21 @@
[vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
@ -467,74 +197,20 @@
[horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL

432
tests/wpt/metadata-layout-2020/css/cssom/getComputedStyle-insets-relative.html.ini
View file

@ -1,432 +0,0 @@
[getComputedStyle-insets-relative.html]
[vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
expected: FAIL
[vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels]
expected: FAIL
[vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
expected: FAIL
[horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
expected: FAIL
[vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
expected: FAIL
[vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
expected: FAIL