Update test expectation

2025-07-31 19:20:22 +01:00 · 2019-10-19 00:31:43 +09:00 · 2019-10-19 00:31:43 +09:00 · e7bc0fae4c
commit e7bc0fae4c
parent 1cc6435cfc
73 changed files with 4293 additions and 544 deletions
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-absolute.html.ini
@ -1,2 +1,973 @@
 [getComputedStyle-insets-absolute.html]
-  expected: TIMEOUT
+  [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are 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-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is]
+    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
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
+    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-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end 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-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    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
+
+  [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [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
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 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
+
+  [vertical-rl ltr inside vertical-lr rtl - Relative lengths 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
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - 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-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end 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 ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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 vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end 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-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end 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-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    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 horizontal-tb rtl - Pixels resolve as-is]
+    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-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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
+
+  [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves 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 rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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
+
+  [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Relative lengths are 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-lr ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Relative lengths 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 - Pixels resolve as-is 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-lr rtl inside vertical-lr ltr - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [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-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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 horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Relative lengths 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 rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are 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-rl rtl inside vertical-rl ltr - If start side is 'auto' and end 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 ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end 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 ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [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
+
+  [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [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 ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths 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-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
+    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
+
+  [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    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-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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 vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    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-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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
+
+  [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
+    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 horizontal-tb ltr - Pixels resolve as-is]
+    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
+
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-fixed.html.ini
@ -1,2 +1,973 @@
 [getComputedStyle-insets-fixed.html]
-  expected: TIMEOUT
+  [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are 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-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is]
+    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
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
+    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-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end 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-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    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
+
+  [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [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
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 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
+
+  [vertical-rl ltr inside vertical-lr rtl - Relative lengths 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
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - 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-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end 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 ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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 vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end 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-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end 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-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    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 horizontal-tb rtl - Pixels resolve as-is]
+    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-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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
+
+  [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves 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 rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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
+
+  [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Relative lengths are 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-lr ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Relative lengths 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 - Pixels resolve as-is 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-lr rtl inside vertical-lr ltr - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [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-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    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 ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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 horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Relative lengths 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 rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are 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-rl rtl inside vertical-rl ltr - If start side is 'auto' and end 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 ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end 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 ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [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
+
+  [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained]
+    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-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [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 ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths 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-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained]
+    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
+
+  [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
+    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
+
+  [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained]
+    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 - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    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-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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 vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    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-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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
+
+  [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
+    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 horizontal-tb ltr - Pixels resolve as-is]
+    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
+
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-nobox.html.ini
@ -1,2 +0,0 @@
-[getComputedStyle-insets-nobox.html]
-  expected: TIMEOUT
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-relative.html.ini
@ -1,2 +1,757 @@
 [getComputedStyle-insets-relative.html]
-  expected: TIMEOUT
+  [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [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 rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are 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-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
+    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
+
+  [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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 rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    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 rtl inside vertical-rl rtl - Pixels resolve as-is]
+    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 ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    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 rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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
+
+  [vertical-rl ltr inside vertical-lr rtl - Relative lengths 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
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    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 rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - 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 ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    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-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
+    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-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end 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-rl ltr inside vertical-rl rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
+    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-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Relative lengths are 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 - Pixels resolve as-is]
+    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-lr rtl inside vertical-lr ltr - If start side is 'auto' and end 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-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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 ltr inside vertical-lr rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
+    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
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    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 horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Relative lengths 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 rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are 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 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 - If start side is 'auto' and end 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 ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    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-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves 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
+
+  [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
+    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
+
+  [horizontal-tb rtl inside vertical-lr ltr - Relative lengths 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 - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    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
+
+  [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end 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 - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
+    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-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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 vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    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-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end 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
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    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-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
+    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-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves 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
+
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-static.html.ini
@ -1,2 +0,0 @@
-[getComputedStyle-insets-static.html]
-  expected: TIMEOUT
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html.ini
@ -1,2 +1,757 @@
 [getComputedStyle-insets-sticky-container-for-abspos.html]
-  expected: TIMEOUT
+  [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths 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 ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside 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 rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [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
+
+  [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    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
+
+  [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr 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
+
+  [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [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-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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 rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    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-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    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
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    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 as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb 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 as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [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
+
--- a/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini
+++ b/tests/wpt/metadata/css/cssom/getComputedStyle-insets-sticky.html.ini
@ -1,2 +1,757 @@
 [getComputedStyle-insets-sticky.html]
-  expected: TIMEOUT
+  [horizontal-tb ltr inside horizontal-tb rtl - Relative lengths 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 ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside 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 rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [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
+
+  [vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    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
+
+  [vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr 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
+
+  [vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    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
+
+  [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-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    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 rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr 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 as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - 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 as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    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-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    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
+
+  [horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is]
+    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 as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb 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 as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is]
+    expected: FAIL
+
+  [vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is]
+    expected: FAIL
+
+  [horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is]
+    expected: FAIL
+
+  [vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels]
+    expected: FAIL
+
+  [horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is]
+    expected: FAIL
+
+  [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
+
--- a/tests/wpt/metadata/html/dom/idlharness.https.html.ini
+++ b/tests/wpt/metadata/html/dom/idlharness.https.html.ini
@ -2916,9 +2916,6 @@
  [HTMLInputElement interface: createInput("text") must inherit property "valueAsNumber" with the proper type]
    expected: FAIL

-  [HTMLScriptElement interface: attribute noModule]
-    expected: FAIL
-
  [HTMLInputElement interface: createInput("checkbox") must inherit property "stepDown(long)" with the proper type]
    expected: FAIL

@ -3828,9 +3825,6 @@
  [HTMLInputElement interface: createInput("text") must inherit property "useMap" with the proper type]
    expected: FAIL

-  [HTMLScriptElement interface: document.createElement("script") must inherit property "noModule" with the proper type]
-    expected: FAIL
-
  [HTMLTableSectionElement interface: document.createElement("thead") must inherit property "align" with the proper type]
    expected: FAIL

--- a/tests/wpt/metadata/html/dom/reflection-misc.html.ini
+++ b/tests/wpt/metadata/html/dom/reflection-misc.html.ini
@ -17610,102 +17610,6 @@
  [script.nonce: IDL set to object "test-valueOf"]
    expected: FAIL

-  [script.noModule: typeof IDL attribute]
-    expected: FAIL
-
-  [script.noModule: IDL get with DOM attribute unset]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to ""]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to " foo "]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to undefined]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to null]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to 7]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to 1.5]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to true]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to false]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to object "[object Object\]"]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to NaN]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to Infinity]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to -Infinity]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to "\\0"]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to object "test-toString"]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to object "test-valueOf"]
-    expected: FAIL
-
-  [script.noModule: setAttribute() to "noModule"]
-    expected: FAIL
-
-  [script.noModule: IDL set to ""]
-    expected: FAIL
-
-  [script.noModule: IDL set to " foo "]
-    expected: FAIL
-
-  [script.noModule: IDL set to undefined]
-    expected: FAIL
-
-  [script.noModule: IDL set to null]
-    expected: FAIL
-
-  [script.noModule: IDL set to 7]
-    expected: FAIL
-
-  [script.noModule: IDL set to 1.5]
-    expected: FAIL
-
-  [script.noModule: IDL set to false]
-    expected: FAIL
-
-  [script.noModule: IDL set to object "[object Object\]"]
-    expected: FAIL
-
-  [script.noModule: IDL set to NaN]
-    expected: FAIL
-
-  [script.noModule: IDL set to Infinity]
-    expected: FAIL
-
-  [script.noModule: IDL set to -Infinity]
-    expected: FAIL
-
-  [script.noModule: IDL set to "\\0"]
-    expected: FAIL
-
-  [script.noModule: IDL set to object "test-toString"]
-    expected: FAIL
-
-  [script.noModule: IDL set to object "test-valueOf"]
-    expected: FAIL
-
  [menu.type: setAttribute() to "context"]
    expected: FAIL

@ -19212,9 +19116,6 @@
  [undefinedelement.tabIndex: setAttribute() to "5%"]
    expected: FAIL

-  [script.noModule: setAttribute() to "5%"]
-    expected: FAIL
-
  [undefinedelement.dir: setAttribute() to "5%"]
    expected: FAIL

@ -19416,9 +19317,6 @@
  [details.dir: setAttribute() to "5%"]
    expected: FAIL

-  [script.noModule: IDL set to "5%"]
-    expected: FAIL
-
  [summary.dir: IDL set to "5%"]
    expected: FAIL

@ -19440,9 +19338,6 @@
  [script.accessKey: IDL set to "+100"]
    expected: FAIL

-  [script.noModule: IDL set to "+100"]
-    expected: FAIL
-
  [ins.dateTime: IDL set to "+100"]
    expected: FAIL

@ -19581,9 +19476,6 @@
  [details.tabIndex: setAttribute() to "+100"]
    expected: FAIL

-  [script.noModule: setAttribute() to "+100"]
-    expected: FAIL
-
  [script.dir: setAttribute() to ".5"]
    expected: FAIL

@ -19611,9 +19503,6 @@
  [menu.dir: IDL set to ".5"]
    expected: FAIL

-  [script.noModule: IDL set to ".5"]
-    expected: FAIL
-
  [dialog.tabIndex: setAttribute() to "+100"]
    expected: FAIL

@ -19839,9 +19728,6 @@
  [dialog.dir: IDL set to "+100"]
    expected: FAIL

-  [script.noModule: setAttribute() to ".5"]
-    expected: FAIL
-
  [undefinedelement.enterKeyHint: setAttribute() to "+100"]
    expected: FAIL

--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/css-module/utf8.tentative.html.ini
@ -1,14 +1,13 @@
 [utf8.tentative.html]
-  expected: TIMEOUT
  [windows-1252]
-    expected: NOTRUN
+    expected: FAIL

  [utf-7]
-    expected: NOTRUN
+    expected: FAIL

  [shift-jis]
-    expected: NOTRUN
+    expected: FAIL

  [utf-8]
-    expected: NOTRUN
+    expected: FAIL

--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-01.html.ini
@ -1,3 +0,0 @@
-[charset-01.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-02.html.ini
@ -1,3 +1,7 @@
 [charset-02.html]
-  type: testharness
-  expected: TIMEOUT
+  [UTF-16 module script with UTF-16LE BOM]
+    expected: FAIL
+
+  [UTF-16 module script with UTF-16BE BOM]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/charset-03.html.ini
@ -1,3 +0,0 @@
-[charset-03.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-1.html.ini
@ -1,4 +0,0 @@
-[choice-of-error-1.html]
-  [Parse errors in different files should be reported depending on different roots]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-2.html.ini
@ -1,4 +0,0 @@
-[choice-of-error-2.html]
-  [Instantiation errors in different files should be reported depending on different roots]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/choice-of-error-3.html.ini
@ -1,4 +0,0 @@
-[choice-of-error-3.html]
-  [Evaluation errors are cached in intermediate module scripts]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-1.html.ini
@ -1,5 +0,0 @@
-[compilation-error-1.html]
-  type: testharness
-  [Test that syntax errors lead to SyntaxError events on window, and that exceptions are remembered.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/compilation-error-2.html.ini
@ -1,5 +0,0 @@
-[compilation-error-2.html]
-  type: testharness
-  [Test that syntax errors lead to SyntaxError events on window, and that exceptions are remembered.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/credentials.sub.html.ini
@ -1,3 +1,4 @@
+
 [credentials.sub.html]
  type: testharness
  [Modules should be loaded with or without the credentials based on the same-origin-ness and the crossOrigin attribute]
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/crossorigin.html.ini
@ -1,32 +0,0 @@
-[crossorigin.html]
-  type: testharness
-  [Root module, Error in CORS-different-origin script]
-    expected: FAIL
-
-  [Root module, Error in CORS-same-origin script]
-    expected: FAIL
-
-  [Root module, Blocked script download, missing CORS ACAO header]
-    expected: FAIL
-
-  [Root module, Blocked script download, mismatched CORS ACAO header]
-    expected: FAIL
-
-  [Imported module, Error in CORS-different-origin script]
-    expected: FAIL
-
-  [Imported module, Error in CORS-same-origin script]
-    expected: FAIL
-
-  [Imported module, Blocked script download, missing CORS ACAO header]
-    expected: FAIL
-
-  [Imported module, Blocked script download, mismatched CORS ACAO header]
-    expected: FAIL
-
-  [Root module, Blocked script download, crossorigin attribute with missing CORS ACAO header]
-    expected: FAIL
-
-  [Imported module, Blocked script download, crossorigin attribute with missing CORS ACAO header]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/currentScript-null.html.ini
@ -1,3 +0,0 @@
-[currentScript-null.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/custom-element-exception.html.ini
@ -1,5 +0,0 @@
-[custom-element-exception.html]
-  type: testharness
-  [Test that exceptions from the constructor of a custom element inside a module are propagated as expected.\n]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-1.html.ini
@ -1,2 +0,0 @@
-[duplicated-imports-1.html]
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/duplicated-imports-2.html.ini
@ -1,2 +0,0 @@
-[duplicated-imports-2.html]
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-and-slow-dependency.html.ini
@ -1,3 +0,0 @@
-[error-and-slow-dependency.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-1.html.ini
@ -1,4 +0,0 @@
-[error-type-1.html]
-  [network error has higher priority than parse error]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-2.html.ini
@ -1,4 +0,0 @@
-[error-type-2.html]
-  [parse error has higher priority than instantiation error]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/error-type-3.html.ini
@ -1,4 +0,0 @@
-[error-type-3.html]
-  [instantiation error has higher priority than evaluation error]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/errorhandling.html.ini
@ -1,18 +0,0 @@
-[errorhandling.html]
-  type: testharness
-  expected: TIMEOUT
-  [IFrame test: 'iframe_parseError_Root']
-    expected: FAIL
-
-  [IFrame test: 'iframe_parseError_Dependent']
-    expected: FAIL
-
-  [IFrame test: 'iframe_parseError_DependentMultiple']
-    expected: FAIL
-
-  [External root module with non-script mimetype]
-    expected: NOTRUN
-
-  [Module with imported non-script mimetype]
-    expected: NOTRUN
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-1.html.ini
@ -1,5 +0,0 @@
-[evaluation-error-1.html]
-  type: testharness
-  [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-2.html.ini
@ -1,5 +0,0 @@
-[evaluation-error-2.html]
-  type: testharness
-  [Test that ill-founded cyclic dependencies cause ReferenceError during evaluation, which leads to error events on window, and that exceptions are remembered.\n]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-3.html.ini
@ -1,5 +0,0 @@
-[evaluation-error-3.html]
-  type: testharness
-  [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/evaluation-error-4.html.ini
@ -1,5 +0,0 @@
-[evaluation-error-4.html]
-  type: testharness
-  [Test that exceptions during evaluation lead to error events on window, and that exceptions are remembered.\n]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/execorder.html.ini
@ -1,21 +0,0 @@
-[execorder.html]
-  type: testharness
-  expected: TIMEOUT
-  [Unordered module script execution (parsed, unordered #1)]
-    expected: NOTRUN
-
-  [Unordered module script execution (parsed, unordered #2)]
-    expected: NOTRUN
-
-  [Unordered module script execution (dynamic, unordered #1)]
-    expected: NOTRUN
-
-  [Unordered module script execution (dynamic, unordered #2)]
-    expected: NOTRUN
-
-  [Interlaced module/non-module script execution (parsed, async-ordered)]
-    expected: FAIL
-
-  [Interlaced module/non-module script execution (dynamic, async-ordered)]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-1.html.ini
@ -1,5 +0,0 @@
-[fetch-error-1.html]
-  type: testharness
-  [Test that failure to fetch root leads to error event on script.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/fetch-error-2.html.ini
@ -1,5 +0,0 @@
-[fetch-error-2.html]
-  type: testharness
-  [Test that failure to fetch dependency leads to error event on script.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/import-subgraph-404.html.ini
@ -1,3 +0,0 @@
-[import-subgraph-404.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/imports.html.ini
@ -1,15 +0,0 @@
-[imports.html]
-  type: testharness
-  expected: TIMEOUT
-  [Import a module that tries to import itself]
-    expected: NOTRUN
-
-  [Import a module with a cyclical module dependency]
-    expected: NOTRUN
-
-  [Import a module that validly imports itself]
-    expected: NOTRUN
-
-  [Import a module with a valid cyclical module dependency]
-    expected: NOTRUN
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inactive-context-import.html.ini
@ -0,0 +1,5 @@
+[inactive-context-import.html]
+  type: testharness
+  [dynamic import from inactive context should not crash]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/inline-async-execorder.html.ini
@ -1,4 +0,0 @@
-[inline-async-execorder.html]
-  [Inline async module script execution order]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-1.html.ini
@ -1,8 +0,0 @@
-[instantiation-error-1.html]
-  type: testharness
-  [Test that missing exports lead to SyntaxError events on window and load events on script, and that exceptions are remembered]
-    expected: FAIL
-
-  [Test that missing exports lead to SyntaxError events on window and load events on script]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-2.html.ini
@ -1,8 +0,0 @@
-[instantiation-error-2.html]
-  type: testharness
-  [Test that missing exports lead to SyntaxError events on window and load events on script, and that exceptions are remembered]
-    expected: FAIL
-
-  [Test that missing exports lead to SyntaxError events on window and load events on script]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-3.html.ini
@ -1,8 +0,0 @@
-[instantiation-error-3.html]
-  type: testharness
-  [Test that unresolvable cycles lead to SyntaxError events on window and load events on script, and that exceptions are remembered]
-    expected: FAIL
-
-  [Test that unresolvable cycles lead to SyntaxError events on window and load events on script]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-4.html.ini
@ -1,8 +0,0 @@
-[instantiation-error-4.html]
-  type: testharness
-  [Test that loading a graph in which a module is already errored results in that module's error.]
-    expected: FAIL
-
-  [Test that loading a graph in which a module is already errored results in an error.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-5.html.ini
@ -1,8 +0,0 @@
-[instantiation-error-5.html]
-  type: testharness
-  [Test that loading a graph in which a module is already errored results in that module's error.]
-    expected: FAIL
-
-  [Test that loading a graph in which a module is already errored results an error.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-6.html.ini
@ -1,5 +0,0 @@
-[instantiation-error-6.html]
-  type: testharness
-  [Test that ambiguous star exports lead to an instantiation error and that the correct module is blamed.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-7.html.ini
@ -1,5 +0,0 @@
-[instantiation-error-7.html]
-  type: testharness
-  [Test that ambiguous star exports lead to an instantiation error, even when discovered through a star export, and that the correct module is blamed.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/instantiation-error-8.html.ini
@ -1,6 +0,0 @@
-[instantiation-error-8.html]
-  type: testharness
-  expected: TIMEOUT
-  [Instantiate attempt on a tree w/ previously instantiate-failed tree as a sub-tree shouldn't crash.]
-    expected: TIMEOUT
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/integrity.html.ini
@ -1,3 +0,0 @@
-[integrity.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-namespace-request.html.ini
@ -1,5 +0,0 @@
-[late-namespace-request.html]
-  type: testharness
-  [Test the situation where a module is instantiated without the need for a namespace object, but later on a different module requests the namespace.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/late-star-export-request.html.ini
@ -1,5 +0,0 @@
-[late-star-export-request.html]
-  type: testharness
-  [Test the situation where a module is instantiated without a use of its star-exports, but later on a different module requests them.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events-inline.html.ini
@ -1,27 +1,5 @@
+
 [load-error-events-inline.html]
  type: testharness
-  expected: TIMEOUT
-  [src, 200, parser-inserted, defer, no async]
-    expected: NOTRUN
-
-  [src, 200, parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 200, not parser-inserted, no defer, no async, no non-blocking]
-    expected: NOTRUN
-
-  [src, 200, not parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 404, parser-inserted, defer, no async]
-    expected: NOTRUN
-
-  [src, 404, parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 404, not parser-inserted, no defer, no async, no non-blocking]
-    expected: NOTRUN
-
-  [src, 404, not parser-inserted, no defer, async]
-    expected: NOTRUN
+  expected: CRASH

--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/load-error-events.html.ini
@ -1,27 +0,0 @@
-[load-error-events.html]
-  type: testharness
-  expected: TIMEOUT
-  [src, 200, parser-inserted, defer, no async]
-    expected: NOTRUN
-
-  [src, 200, parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 200, not parser-inserted, no defer, no async, no non-blocking]
-    expected: NOTRUN
-
-  [src, 200, not parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 404, parser-inserted, defer, no async]
-    expected: NOTRUN
-
-  [src, 404, parser-inserted, no defer, async]
-    expected: NOTRUN
-
-  [src, 404, not parser-inserted, no defer, no async, no non-blocking]
-    expected: NOTRUN
-
-  [src, 404, not parser-inserted, no defer, async]
-    expected: NOTRUN
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-in-xhtml.xhtml.ini
@ -1,5 +0,0 @@
-[module-in-xhtml.xhtml]
-  type: testharness
-  [module script in XHTML documents should be evaluated.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-1.html.ini
@ -1,5 +0,0 @@
-[module-vs-script-1.html]
-  type: testharness
-  [Test that evaluating something as classic script does not prevent it from being evaluated as module script.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/module-vs-script-2.html.ini
@ -1,5 +0,0 @@
-[module-vs-script-2.html]
-  type: testharness
-  [Test that evaluating something as classic script does not prevent it from being evaluated as module script.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/nomodule-attribute.html.ini
@ -1,5 +0,0 @@
-[nomodule-attribute.html]
-  type: testharness
-  [Test that 'nomodule' has the desired effect on classic scripts, but no effect on module scripts.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-no-referrer.sub.html.ini
@ -1,2 +0,0 @@
-[referrer-no-referrer.sub.html]
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin-when-cross-origin.sub.html.ini
@ -1,2 +1,19 @@
 [referrer-origin-when-cross-origin.sub.html]
-  expected: TIMEOUT
+  [Importing a remote-origin descendant script from a same-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin descendant script from a same-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
+  [Importing a remote-origin descendant script from a remote-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin descendant script from a remote-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
+  [Importing a remote-origin top-level script with the origin-when-cross-origin policy.]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-origin.sub.html.ini
@ -1,2 +1,19 @@
 [referrer-origin.sub.html]
-  expected: TIMEOUT
+  [Importing a same-origin descendant script from a same-origin top-level script with the origin policy.]
+    expected: FAIL
+
+  [Importing a remote-origin descendant script from a same-origin top-level script with the origin policy.]
+    expected: FAIL
+
+  [Importing a remote-origin descendant script from a remote-origin top-level script with the origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin descendant script from a remote-origin top-level script with the origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin top-level script with the origin policy.]
+    expected: FAIL
+
+  [Importing a remote-origin top-level script with the origin policy.]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-same-origin.sub.html.ini
@ -1,2 +1,10 @@
 [referrer-same-origin.sub.html]
-  expected: TIMEOUT
+  [Importing a same-origin descendant script from a same-origin top-level script with the same-origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin descendant script from a remote-origin top-level script with the same-origin policy.]
+    expected: FAIL
+
+  [Importing a same-origin top-level script with the same-origin policy.]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/referrer-unsafe-url.sub.html.ini
@ -1,2 +1,19 @@
 [referrer-unsafe-url.sub.html]
-  expected: TIMEOUT
+  [Importing a same-origin descendant script from a remote-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
+  [Importing a same-origin descendant script from a same-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
+  [Importing a remote-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
+  [Importing a remote-origin descendant script from a remote-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
+  [Importing a remote-origin descendant script from a same-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
+  [Importing a same-origin top-level script with the unsafe-url policy.]
+    expected: FAIL
+
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/script-for-event.html.ini
@ -1,3 +0,0 @@
-[script-for-event.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-1.html.ini
@ -1,5 +0,0 @@
-[single-evaluation-1.html]
-  type: testharness
-  [Test that a module is evaluated only once, and that 'this' is undefined (because of strict mode).]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/single-evaluation-2.html.ini
@ -1,5 +0,0 @@
-[single-evaluation-2.html]
-  type: testharness
-  [Test that a module is evaluated only once, and that 'this' is undefined (because of strict mode).]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/slow-cycle.html.ini
@ -1,3 +0,0 @@
-[slow-cycle.html]
-  type: testharness
-  expected: TIMEOUT
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/module/specifier-error.html.ini
@ -1,5 +0,0 @@
-[specifier-error.html]
-  type: testharness
-  [Test that invalid module specifier leads to TypeError on window.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-reflect.html.ini
@ -1,32 +0,0 @@
-[nomodule-reflect.html]
-  type: testharness
-  [noModule IDL attribute on a parser created classic script element without nomodule content attribute]
-    expected: FAIL
-
-  [noModule IDL attribute on a parser created classic script element with nomodule content attribute]
-    expected: FAIL
-
-  [noModule IDL attribute on a parser created module script element without nomodule content attribute]
-    expected: FAIL
-
-  [noModule IDL attribute on a parser created module script element with nomodule content attribute]
-    expected: FAIL
-
-  [noModule IDL attribute on a dynamically created script element without nomodule content attribute]
-    expected: FAIL
-
-  [noModule IDL attribute on a dynamically created script element after nomodule content attribute is set to "nomodule"]
-    expected: FAIL
-
-  [noModule IDL attribute on a dynamically created script element after nomodule content attribute is set to ""]
-    expected: FAIL
-
-  [noModule IDL attribute on a dynamically created script element after nomodule content attribute had been removed]
-    expected: FAIL
-
-  [noModule IDL attribute must add nomodule content attribute on setting to true]
-    expected: FAIL
-
-  [noModule IDL attribute must remove nomodule content attribute on setting to false]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-async-classic-script.html.ini
@ -1,8 +0,0 @@
-[nomodule-set-on-async-classic-script.html]
-  type: testharness
-  [An asynchronously loaded classic script with noModule set to true must not run]
-    expected: FAIL
-
-  [An asynchronously loaded classic script with noModule set to false must run]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-external-module-script.html.ini
@ -1,5 +0,0 @@
-[nomodule-set-on-external-module-script.html]
-  type: testharness
-  [An external module script with nomodule content attribute must run]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-classic-scripts.html.ini
@ -1,8 +0,0 @@
-[nomodule-set-on-inline-classic-scripts.html]
-  type: testharness
-  [An inline classic script with nomodule content attribute must not run]
-    expected: FAIL
-
-  [An inline classic script element dynamically inserted after noModule was set to true must not run.]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-inline-module-script.html.ini
@ -1,5 +0,0 @@
-[nomodule-set-on-inline-module-script.html]
-  type: testharness
-  [An inline module script with nomodule content attribute must run]
-    expected: FAIL
-
--- a/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini
+++ b/tests/wpt/metadata/html/semantics/scripting-1/the-script-element/nomodule-set-on-synchronously-loaded-classic-scripts.html.ini
@ -1,5 +0,0 @@
-[nomodule-set-on-synchronously-loaded-classic-scripts.html]
-  type: testharness
-  [A synchronously loaded external classic script with nomodule content attribute must not run]
-    expected: FAIL
-