Resolve inset properties to computed style when there is overconstraintment
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 9 Oct 2018 20:11:04 +0000 (20:11 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 9 Oct 2018 20:11:04 +0000 (20:11 +0000)
https://bugs.webkit.org/show_bug.cgi?id=188711

Patch by Oriol Brufau <obrufau@igalia.com> on 2018-10-09
Reviewed by Manuel Rego Casasnovas.

This patch makes WebKit behave closer to Blink. Specifically,
 - In overconstrained relative or absolute positioning, inset properties resolve
   to the computed value (absolutizing percentages) instead of to the used value.
 - In fixed positioning, the resolved value of non-'auto' values is no longer
   increased by the border of the containg block.

LayoutTests/imported/w3c:

Some tests still have failures due to
 - https://bugs.webkit.org/show_bug.cgi?id=189513
 - https://bugs.webkit.org/show_bug.cgi?id=189518
 - https://bugs.webkit.org/show_bug.cgi?id=189549

This patch can slighlty alter the resolved value if it's a long decimal number,
that's why test expectations for the timing functions test changed.

* web-platform-tests/css-timing-1/cubic-bezier-timing-functions-output-expected.txt:
* web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-relative-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-relative.html: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-static.html: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html: Added.
* web-platform-tests/css/cssom/support/getComputedStyle-insets.js: Added.
(serialize):
(wmName):
(checkStyle):
(runTestsWithWM):
(export.runTests):

Source/WebCore:

This patch can slighlty alter the resolved value if it's a long decimal number.

Tests: imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html

* css/CSSComputedStyleDeclaration.cpp:
(WebCore::positionOffsetValue):
* rendering/RenderBox.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@236979 268f45cc-cd09-0410-ab3c-d52691b4dbfc

18 files changed:
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/css-timing-1/cubic-bezier-timing-functions-output-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html [new file with mode: 0755]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js [new file with mode: 0755]
Source/WebCore/ChangeLog
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/rendering/RenderBox.h

index 937913d..036a10e 100644 (file)
@@ -1,3 +1,44 @@
+2018-10-09  Oriol Brufau  <obrufau@igalia.com>
+
+        Resolve inset properties to computed style when there is overconstraintment
+        https://bugs.webkit.org/show_bug.cgi?id=188711
+
+        Reviewed by Manuel Rego Casasnovas.
+
+        This patch makes WebKit behave closer to Blink. Specifically,
+         - In overconstrained relative or absolute positioning, inset properties resolve
+           to the computed value (absolutizing percentages) instead of to the used value.
+         - In fixed positioning, the resolved value of non-'auto' values is no longer
+           increased by the border of the containg block.
+
+        Some tests still have failures due to
+         - https://bugs.webkit.org/show_bug.cgi?id=189513
+         - https://bugs.webkit.org/show_bug.cgi?id=189518
+         - https://bugs.webkit.org/show_bug.cgi?id=189549
+
+        This patch can slighlty alter the resolved value if it's a long decimal number,
+        that's why test expectations for the timing functions test changed.
+
+        * web-platform-tests/css-timing-1/cubic-bezier-timing-functions-output-expected.txt:
+        * web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-relative-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-relative.html: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-static.html: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html: Added.
+        * web-platform-tests/css/cssom/support/getComputedStyle-insets.js: Added.
+        (serialize):
+        (wmName):
+        (checkStyle):
+        (runTestsWithWM):
+        (export.runTests):
+
 2018-10-08  Truitt Savell  <tsavell@apple.com>
 
         Attempt to fix test failure after 236915
index 497c989..9d8aa86 100644 (file)
@@ -1,6 +1,6 @@
 
-FAIL cubic-bezier easing with input progress greater than 1 assert_approx_equals: The left of the animation should be approximately 98.8706654939602 at 230ms expected 98.8706654939602 +/- 0.01 but got 98.890625
-FAIL cubic-bezier easing with input progress greater than 1 and where the tangent on the upper boundary is infinity assert_approx_equals: The left of the animation should be approximately 106.31755608768113 at 230ms expected 106.31755608768113 +/- 0.01 but got 106.359375
-FAIL cubic-bezier easing with input progress less than 0 assert_approx_equals: The left of the animation should be approximately -16.589193103032184 at 10ms expected -16.589193103032184 +/- 0.01 but got -17.5
-FAIL cubic-bezier easing with input progress less than 0 and where the tangent on the lower boundary is infinity assert_approx_equals: The left of the animation should be approximately 0 at 300ms expected 0 +/- 0.01 but got 512.0625
+FAIL cubic-bezier easing with input progress greater than 1 assert_approx_equals: The left of the animation should be approximately 98.8706654939602 at 230ms expected 98.8706654939602 +/- 0.01 but got 98.89859008789062
+FAIL cubic-bezier easing with input progress greater than 1 and where the tangent on the upper boundary is infinity assert_approx_equals: The left of the animation should be approximately 106.31755608768113 at 230ms expected 106.31755608768113 +/- 0.01 but got 106.3595962524414
+FAIL cubic-bezier easing with input progress less than 0 assert_approx_equals: The left of the animation should be approximately -16.589193103032184 at 10ms expected -16.589193103032184 +/- 0.01 but got -17.50836753845215
+FAIL cubic-bezier easing with input progress less than 0 and where the tangent on the lower boundary is infinity assert_approx_equals: The left of the animation should be approximately 0 at 300ms expected 0 +/- 0.01 but got 512.0774536132812
 
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt
new file mode 100644 (file)
index 0000000..4a1800c
--- /dev/null
@@ -0,0 +1,326 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "185px" but got "30px"
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "185px" but got "30px"
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "185px" but got "30px"
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "185px" but got "30px"
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "370px"
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "370px" but got "30px"
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "370px" but got "30px"
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "370px"
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "370px" but got "30px"
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "370px" but got "30px"
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "370px"
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "30px" but got "370px"
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "30px" but got "370px"
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "30px"
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "15px" but got "370px"
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "30px" but got "370px"
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+FAIL vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'left' expected "30px" but got "370px"
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html
new file mode 100755 (executable)
index 0000000..fae0a84
--- /dev/null
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for absolute positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForAbspos} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: absolute",
+  containingBlockElement: containerForAbspos,
+  containingBlockArea: "padding",
+  preservesPercentages: false,
+  preservesAuto: false,
+  canStretchAutoSize: true,
+  staticPositionY: 1 + 2 + 4 + 8,
+  staticPositionX: 2 + 4 + 8 + 16,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt
new file mode 100644 (file)
index 0000000..1c94629
--- /dev/null
@@ -0,0 +1,326 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "382px"
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "382px"
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "382px"
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "382px"
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "474px"
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "474px"
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "474px"
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "382px"
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "474px"
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "127px" but got "255px"
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is when overconstrained 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages absolutize the computed value when overconstrained 
+FAIL vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value assert_equals: 'top' expected "297px" but got "425px"
+FAIL vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value assert_equals: 'bottom' expected "299px" but got "171px"
+FAIL vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value assert_equals: 'top' expected "173px" but got "301px"
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html
new file mode 100755 (executable)
index 0000000..ff80d2f
--- /dev/null
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for fixed positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForFixed} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: fixed",
+  containingBlockElement: containerForFixed,
+  containingBlockArea: "padding",
+  preservesPercentages: false,
+  preservesAuto: false,
+  canStretchAutoSize: true,
+  staticPositionY: 1 + 2 + 4 + 8 + 16 + 32 + 64,
+  staticPositionX: 2 + 4 + 8 + 16 + 32 + 64 + 128,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt
new file mode 100644 (file)
index 0000000..cbcbf79
--- /dev/null
@@ -0,0 +1,218 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html
new file mode 100755 (executable)
index 0000000..236abf1
--- /dev/null
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties when the element generates no box</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "display: none",
+  containingBlockElement: null,
+  preservesPercentages: true,
+  preservesAuto: true,
+  canStretchAutoSize: false,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative-expected.txt
new file mode 100644 (file)
index 0000000..bc629b0
--- /dev/null
@@ -0,0 +1,254 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves to used value 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve to used value 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html
new file mode 100755 (executable)
index 0000000..1abfc62
--- /dev/null
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for relative positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForInflow} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: relative",
+  containingBlockElement: containerForInflow,
+  containingBlockArea: "content",
+  preservesPercentages: false,
+  preservesAuto: false,
+  canStretchAutoSize: false,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt
new file mode 100644 (file)
index 0000000..cbcbf79
--- /dev/null
@@ -0,0 +1,218 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html
new file mode 100755 (executable)
index 0000000..aa7dbee
--- /dev/null
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for static positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForInflow} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: static",
+  containingBlockElement: containerForInflow,
+  containingBlockArea: "content",
+  preservesPercentages: true,
+  preservesAuto: true,
+  canStretchAutoSize: false,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt
new file mode 100644 (file)
index 0000000..436ed0c
--- /dev/null
@@ -0,0 +1,254 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+FAIL vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
+FAIL vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html
new file mode 100755 (executable)
index 0000000..6149acc
--- /dev/null
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for sticky positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForInflow} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: sticky; position: -webkit-sticky",
+  containingBlockElement: containerForInflow,
+  containingBlockArea: "content",
+  preservesPercentages: false,
+  preservesAuto: true,
+  canStretchAutoSize: false,
+});
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js
new file mode 100755 (executable)
index 0000000..beec32e
--- /dev/null
@@ -0,0 +1,376 @@
+export const testEl = document.createElement("div");
+export const containerForInflow = document.createElement("div");
+export const containerForAbspos = document.createElement("div");
+export const containerForFixed = document.createElement("div");
+
+testEl.id = "test";
+containerForInflow.id = "container-for-inflow";
+containerForAbspos.id = "container-for-abspos";
+containerForFixed.id = "container-for-fixed";
+
+containerForInflow.appendChild(testEl);
+containerForAbspos.appendChild(containerForInflow);
+containerForFixed.appendChild(containerForAbspos);
+document.body.appendChild(containerForFixed);
+
+const stylesheet = document.createElement("style");
+stylesheet.textContent = `
+  #container-for-inflow {
+    /* Content area: 100px tall, 200px wide */
+    height: 100px;
+    width: 200px;
+    padding: 1px 2px;
+    border-width: 2px 4px;
+    margin: 4px 8px;
+    overflow: hidden;
+  }
+  #container-for-abspos {
+    /* Padding area: 200px tall, 400px wide */
+    height: 184px;
+    width: 368px;
+    padding: 8px 16px;
+    border-width: 16px 32px;
+    margin: 32px 64px;
+    position: relative;
+  }
+  #container-for-fixed {
+    /* Padding area: 300px tall, 600px wide */
+    height: 172px;
+    width: 344px;
+    padding: 64px 128px;
+    border-width: 128px 256px;
+    margin: 256px 512px;
+    position: absolute;
+    transform: scale(1);
+    visibility: hidden;
+  }
+  [id ^= container] {
+    border-style: solid;
+  }
+`;
+document.head.appendChild(stylesheet);
+
+function runTestsWithWM(data, testWM, cbWM) {
+  const {
+    style,
+    containingBlockElement,
+    containingBlockArea,
+    preservesPercentages,
+    preservesAuto,
+    canStretchAutoSize,
+    staticPositionX,
+    staticPositionY,
+  } = data;
+
+  let cbHeight = containingBlockElement ? containingBlockElement.clientHeight : NaN;
+  let cbWidth = containingBlockElement ? containingBlockElement.clientWidth : NaN;
+  if (containingBlockElement && containingBlockArea == "content") {
+    const cs = getComputedStyle(containingBlockElement);
+    cbHeight -= parseFloat(cs.paddingTop) + parseFloat(cs.paddingBottom);
+    cbWidth -= parseFloat(cs.paddingLeft) + parseFloat(cs.paddingRight);
+  }
+
+  const staticPositionTop = cbWM.blockStart == "top" || cbWM.inlineStart == "top"
+    ? staticPositionY : cbHeight - staticPositionY;
+  const staticPositionLeft = cbWM.blockStart == "left" || cbWM.inlineStart == "left"
+    ? staticPositionX : cbWidth - staticPositionX;
+  const staticPositionBottom = cbWM.blockStart == "bottom" || cbWM.inlineStart == "bottom"
+    ? staticPositionY : cbHeight - staticPositionY;
+  const staticPositionRight = cbWM.blockStart == "right" || cbWM.inlineStart == "right"
+    ? staticPositionX : cbWidth - staticPositionX;
+
+  function serialize(declarations) {
+    return Object.entries(declarations).map(([p, v]) => `${p}: ${v}; `).join("");
+  }
+
+  function wmName(wm) {
+    return Object.values(wm.style).join(" ");
+  }
+
+  function checkStyle(declarations, expected, msg) {
+    test(function() {
+      testEl.style.cssText = style + "; " + serialize(Object.assign({}, declarations, testWM.style));
+      if (containingBlockElement) {
+        containingBlockElement.style.cssText = serialize(Object.assign({}, cbWM.style));
+      }
+      const cs = getComputedStyle(testEl);
+      for (let [prop, value] of Object.entries(expected)) {
+        assert_equals(cs[prop], value, `'${prop}'`);
+      }
+    }, `${wmName(testWM)} inside ${wmName(cbWM)} - ${msg}`);
+
+    testEl.style.cssText = "";
+    if (containingBlockElement) {
+      containingBlockElement.style.cssText = "";
+    }
+  }
+
+  checkStyle({
+    top: "1px",
+    left: "2px",
+    bottom: "3px",
+    right: "4px",
+  }, {
+    top: "1px",
+    left: "2px",
+    bottom: "3px",
+    right: "4px",
+  }, "Pixels resolve as-is");
+
+  checkStyle({
+    top: "1em",
+    left: "2em",
+    bottom: "3em",
+    right: "4em",
+    "font-size": "10px",
+  }, {
+    top: "10px",
+    left: "20px",
+    bottom: "30px",
+    right: "40px",
+  }, "Relative lengths are absolutized into pixels");
+
+  if (preservesPercentages) {
+    checkStyle({
+      top: "10%",
+      left: "25%",
+      bottom: "50%",
+      right: "75%",
+    }, {
+      top: "10%",
+      left: "25%",
+      bottom: "50%",
+      right: "75%",
+    }, "Percentages resolve as-is");
+  } else {
+    checkStyle({
+      top: "10%",
+      left: "25%",
+      bottom: "50%",
+      right: "75%",
+    }, {
+      top: .1 * cbHeight + "px",
+      left: .25 * cbWidth + "px",
+      bottom: .5 * cbHeight + "px",
+      right: .75 * cbWidth + "px",
+    }, "Percentages are absolutized into pixels");
+
+    checkStyle({
+      top: "calc(10% - 1px)",
+      left: "calc(25% - 2px)",
+      bottom: "calc(50% - 3px)",
+      right: "calc(75% - 4px)",
+    }, {
+      top: .1 * cbHeight - 1 + "px",
+      left: .25 * cbWidth - 2 + "px",
+      bottom: .5 * cbHeight - 3 + "px",
+      right: .75 * cbWidth - 4 + "px",
+    }, "calc() is absolutized into pixels");
+  }
+
+  if (canStretchAutoSize) {
+    // Force overconstraintment by setting size or with insets that would result in
+    // negative size. Then the resolved value should be the computed one according to
+    // https://drafts.csswg.org/cssom/#resolved-value-special-case-property-like-top
+
+    checkStyle({
+      top: "1px",
+      left: "2px",
+      bottom: "3px",
+      right: "4px",
+      height: "0px",
+      width: "0px",
+    }, {
+      top: "1px",
+      left: "2px",
+      bottom: "3px",
+      right: "4px",
+    }, "Pixels resolve as-is when overconstrained");
+
+    checkStyle({
+      top: "100%",
+      left: "100%",
+      bottom: "100%",
+      right: "100%",
+    }, {
+      top: cbHeight + "px",
+      left: cbWidth + "px",
+      bottom: cbHeight + "px",
+      right: cbWidth + "px",
+    }, "Percentages absolutize the computed value when overconstrained");
+  }
+
+  if (preservesAuto) {
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "3px",
+      right: "4px",
+    }, {
+      top: "auto",
+      left: "auto",
+      bottom: "3px",
+      right: "4px",
+    }, "If start side is 'auto' and end side is not, 'auto' resolves as-is");
+
+    checkStyle({
+      top: "1px",
+      left: "2px",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: "1px",
+      left: "2px",
+      bottom: "auto",
+      right: "auto",
+    }, "If end side is 'auto' and start side is not, 'auto' resolves as-is");
+
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: "auto",
+      left: "auto",
+      bottom: "auto",
+      right: "auto",
+    }, "If opposite sides are 'auto', they resolve as-is");
+  } else if (canStretchAutoSize) {
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "3px",
+      right: "4px",
+    }, {
+      top: cbHeight - 3 + "px",
+      left: cbWidth - 4 + "px",
+      bottom: "3px",
+      right: "4px",
+    }, "If start side is 'auto' and end side is not, 'auto' resolves to used value");
+
+    checkStyle({
+      top: "1px",
+      left: "2px",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: "1px",
+      left: "2px",
+      bottom: cbHeight - 1 + "px",
+      right: cbWidth - 2 + "px",
+    }, "If end side is 'auto' and start side is not, 'auto' resolves to used value");
+
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: staticPositionTop + "px",
+      left: staticPositionLeft + "px",
+      bottom: staticPositionBottom + "px",
+      right: staticPositionRight + "px",
+    }, "If opposite sides are 'auto', they resolve to used value");
+  } else {
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "3px",
+      right: "4px",
+    }, {
+      top: "-3px",
+      left: "-4px",
+      bottom: "3px",
+      right: "4px",
+    }, "If start side is 'auto' and end side is not, 'auto' resolves to used value");
+
+    checkStyle({
+      top: "1px",
+      left: "2px",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: "1px",
+      left: "2px",
+      bottom: "-1px",
+      right: "-2px",
+    }, "If end side is 'auto' and start side is not, 'auto' resolves to used value");
+
+    checkStyle({
+      top: "auto",
+      left: "auto",
+      bottom: "auto",
+      right: "auto",
+    }, {
+      top: "0px",
+      left: "0px",
+      bottom: "0px",
+      right: "0px",
+    }, "If opposite sides are 'auto', they resolve to used value");
+  }
+}
+
+const writingModes = [{
+  style: {
+    "writing-mode": "horizontal-tb",
+    "direction": "ltr",
+  },
+  blockStart: "top",
+  blockEnd: "bottom",
+  inlineStart: "left",
+  inlineEnd: "right",
+}, {
+  style: {
+    "writing-mode": "horizontal-tb",
+    "direction": "rtl",
+  },
+  blockStart: "top",
+  blockEnd: "bottom",
+  inlineStart: "right",
+  inlineEnd: "left",
+}, {
+  style: {
+    "writing-mode": "vertical-lr",
+    "direction": "ltr",
+  },
+  blockStart: "left",
+  blockEnd: "right",
+  inlineStart: "top",
+  inlineEnd: "bottom",
+}, {
+  style: {
+    "writing-mode": "vertical-lr",
+    "direction": "rtl",
+  },
+  blockStart: "left",
+  blockEnd: "right",
+  inlineStart: "bottom",
+  inlineEnd: "top",
+}, {
+  style: {
+    "writing-mode": "vertical-rl",
+    "direction": "ltr",
+  },
+  blockStart: "right",
+  blockEnd: "left",
+  inlineStart: "top",
+  inlineEnd: "bottom",
+}, {
+  style: {
+    "writing-mode": "vertical-rl",
+    "direction": "rtl",
+  },
+  blockStart: "right",
+  blockEnd: "left",
+  inlineStart: "bottom",
+  inlineEnd: "top",
+}];
+
+export function runTests(data) {
+  for (let testWM of writingModes) {
+    for (let cbWM of writingModes) {
+      runTestsWithWM(data, testWM, cbWM);
+    }
+  }
+}
index 64fb8d1..f2b57ce 100644 (file)
@@ -1,3 +1,29 @@
+2018-10-09  Oriol Brufau  <obrufau@igalia.com>
+
+        Resolve inset properties to computed style when there is overconstraintment
+        https://bugs.webkit.org/show_bug.cgi?id=188711
+
+        Reviewed by Manuel Rego Casasnovas.
+
+        This patch makes WebKit behave closer to Blink. Specifically,
+         - In overconstrained relative or absolute positioning, inset properties resolve
+           to the computed value (absolutizing percentages) instead of to the used value.
+         - In fixed positioning, the resolved value of non-'auto' values is no longer
+           increased by the border of the containg block.
+
+        This patch can slighlty alter the resolved value if it's a long decimal number.
+
+        Tests: imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::positionOffsetValue):
+        * rendering/RenderBox.h:
+
 2018-10-09  Jiewen Tan  <jiewen_tan@apple.com>
 
         [WebAuthN] Import CTAP HID message and packet structure from Chromium
index 5c92c82..2d55ea3 100644 (file)
@@ -764,22 +764,50 @@ static LayoutUnit getOffsetUsedStyleOutOfFlowPositioned(RenderBlock& container,
 
 static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropertyID propertyID, RenderObject* renderer)
 {
+    auto offset = getOffsetComputedLength(style, propertyID);
+
     // If the element is not displayed; return the "computed value".
     if (!renderer || !renderer->isBox())
-        return zoomAdjustedPixelValueForLength(getOffsetComputedLength(style, propertyID), style);
+        return zoomAdjustedPixelValueForLength(offset, style);
 
-    // We should return the "used value".
     auto& box = downcast<RenderBox>(*renderer);
     auto* containingBlock = box.containingBlock();
-    if (box.isRelativelyPositioned() || !containingBlock)
+
+    // Resolve a "computed value" percentage if the element is positioned.
+    // TODO: percentages for sticky positioning should be handled here (bug 189549).
+    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned() && !box.isStickilyPositioned()) {
+        bool isVerticalProperty;
+        if (propertyID == CSSPropertyTop || propertyID == CSSPropertyBottom)
+            isVerticalProperty = true;
+        else {
+            ASSERT(propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight);
+            isVerticalProperty = false;
+        }
+        LayoutUnit containingBlockSize;
+        if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
+            containingBlockSize = box.isOutOfFlowPositioned()
+                ? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)
+                : box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
+        } else {
+            containingBlockSize = box.isOutOfFlowPositioned()
+                ? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)
+                : box.containingBlockLogicalWidthForContent();
+        }
+        return zoomAdjustedPixelValue(floatValueForLength(offset, containingBlockSize), style);
+    }
+
+    // Return a "computed value" length.
+    if (!offset.isAuto())
+        return zoomAdjustedPixelValueForLength(offset, style);
+
+    // The property won't be overconstrained if its computed value is "auto", so the "used value" can be returned.
+    if (box.isRelativelyPositioned())
         return zoomAdjustedPixelValue(getOffsetUsedStyleRelative(box, propertyID), style);
-    if (renderer->isOutOfFlowPositioned())
+
+    if (containingBlock && box.isOutOfFlowPositioned())
         return zoomAdjustedPixelValue(getOffsetUsedStyleOutOfFlowPositioned(*containingBlock, box, propertyID), style);
-    // In-flow element.
-    auto offset = getOffsetComputedLength(style, propertyID);
-    if (offset.isAuto())
-        return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
-    return zoomAdjustedPixelValueForLength(offset, style);
+
+    return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
 }
 
 RefPtr<CSSPrimitiveValue> ComputedStyleExtractor::currentColorOrValidColor(const RenderStyle* style, const Color& color) const
index 7965495..265747e 100644 (file)
@@ -377,7 +377,8 @@ public:
 
     LayoutUnit containingBlockLogicalWidthForContent() const override;
     LayoutUnit containingBlockLogicalHeightForContent(AvailableLogicalHeightType) const;
-
+    LayoutUnit containingBlockLogicalWidthForPositioned(const RenderBoxModelObject& containingBlock, RenderFragmentContainer* = nullptr, bool checkForPerpendicularWritingMode = true) const;
+    LayoutUnit containingBlockLogicalHeightForPositioned(const RenderBoxModelObject& containingBlock, bool checkForPerpendicularWritingMode = true) const;
     LayoutUnit containingBlockLogicalWidthForContentInFragment(RenderFragmentContainer*) const;
     LayoutUnit containingBlockAvailableLineWidthInFragment(RenderFragmentContainer*) const;
     LayoutUnit perpendicularContainingBlockLogicalHeight() const;
@@ -688,9 +689,6 @@ private:
     // Returns true if we did a full repaint.
     bool repaintLayerRectsForImage(WrappedImagePtr, const FillLayer& layers, bool drawingBackground);
 
-    LayoutUnit containingBlockLogicalWidthForPositioned(const RenderBoxModelObject& containingBlock, RenderFragmentContainer* = nullptr, bool checkForPerpendicularWritingMode = true) const;
-    LayoutUnit containingBlockLogicalHeightForPositioned(const RenderBoxModelObject& containingBlock, bool checkForPerpendicularWritingMode = true) const;
-
     void computePositionedLogicalHeight(LogicalExtentComputedValues&) const;
     void computePositionedLogicalWidthUsing(SizeType, Length logicalWidth, const RenderBoxModelObject& containerBlock, TextDirection containerDirection,
                                             LayoutUnit containerLogicalWidth, LayoutUnit bordersPlusPadding,