Attachment 368906 Details for Bug 189549 – Patch

[patch] Patch

bug-189549-20190503152528.patch (text/plain), 72.10 KB, created by Joonghun Park on 2019-05-02 23:25:47 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Joonghun Park

Created: 2019-05-02 23:25:47 PDT

Size: 72.10 KB

patch

obsolete

>Subversion Revision: 244898
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index af347836d9e6fae8beb7509eec4d23c258853ca8..f6412a5156ddd7972b5c8dc263cb9c17f396a9cf 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,27 @@
>+2019-05-02  Joonghun Park  <jh718.park@samsung.com>
>+
>+        Resolve the percentage values of inset properties against proper box.
>+        https://bugs.webkit.org/show_bug.cgi?id=189549
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Before this CL, sticky element's layout was executed relative to
>+        a box's overflow container,
>+        but the value returned by getComputedStyle was resolved against
>+        its containing block.
>+
>+        So, the computed value and the actual value used in layout
>+        was different before this change.
>+
>+        Tests: imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
>+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html
>+
>+        * css/CSSComputedStyleDeclaration.cpp:
>+        (WebCore::positionOffsetValue):
>+        * rendering/RenderBox.cpp:
>+        (WebCore::RenderBox::enclosingScrollportBox const):
>+        * rendering/RenderBox.h:
>+
> 2019-05-02  Ryosuke Niwa  <rniwa@webkit.org>
> 
>         Disable software keyboard for a math field textarea on desmos.com
>diff --git a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>index 2932ba3dfbb1319f22f837a49e7afdadfb1c5fb5..f2dc6b7bd26c55972f83597191f6fb9b9b75a8bd 100644
>--- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>+++ b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>@@ -780,8 +780,7 @@ static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropert
>     auto* containingBlock = box.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()) {
>+    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned()) {
>         bool isVerticalProperty;
>         if (propertyID == CSSPropertyTop || propertyID == CSSPropertyBottom)
>             isVerticalProperty = true;
>@@ -790,14 +789,23 @@ static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropert
>             isVerticalProperty = false;
>         }
>         LayoutUnit containingBlockSize;
>-        if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
>-            containingBlockSize = box.isOutOfFlowPositioned()
>-                ? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)
>-                : box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
>+        if (box.isStickilyPositioned()) {
>+            const RenderBox& enclosingScrollportBox =
>+                box.enclosingScrollportBox();
>+            if (isVerticalProperty == enclosingScrollportBox.isHorizontalWritingMode())
>+                containingBlockSize = enclosingScrollportBox.contentLogicalHeight();
>+            else
>+                containingBlockSize = enclosingScrollportBox.contentLogicalWidth();
>         } else {
>-            containingBlockSize = box.isOutOfFlowPositioned()
>-                ? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)
>-                : box.containingBlockLogicalWidthForContent();
>+            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);
>     }
>diff --git a/Source/WebCore/rendering/RenderBox.cpp b/Source/WebCore/rendering/RenderBox.cpp
>index fbfb3cae45e9cee9e75a4e72e82cd17e7a3724b4..b6bb7e1d3ce6ad0f138b1abc8f76d7572b9568f6 100644
>--- a/Source/WebCore/rendering/RenderBox.cpp
>+++ b/Source/WebCore/rendering/RenderBox.cpp
>@@ -4722,6 +4722,17 @@ RenderLayer* RenderBox::enclosingFloatPaintingLayer() const
>     return nullptr;
> }
> 
>+const RenderBlock& RenderBox::enclosingScrollportBox() const
>+{
>+    const RenderBlock* ancestor = containingBlock();
>+    for (; ancestor; ancestor = ancestor->containingBlock()) {
>+        if (ancestor->hasOverflowClip())
>+            return *ancestor;
>+    }
>+    ASSERT_NOT_REACHED();
>+    return *ancestor;
>+}
>+
> LayoutRect RenderBox::logicalVisualOverflowRectForPropagation(const RenderStyle* parentStyle) const
> {
>     LayoutRect rect = visualOverflowRectForPropagation(parentStyle);
>diff --git a/Source/WebCore/rendering/RenderBox.h b/Source/WebCore/rendering/RenderBox.h
>index 8bcc848a3b34988417740d178e749cc4d3e2db79..51c7ef163acce154dc2b6d7cca20c24eafb5f50f 100644
>--- a/Source/WebCore/rendering/RenderBox.h
>+++ b/Source/WebCore/rendering/RenderBox.h
>@@ -526,6 +526,8 @@ override;
>     void removeFloatingOrPositionedChildFromBlockLists();
>     
>     RenderLayer* enclosingFloatPaintingLayer() const;
>+
>+    const RenderBlock& enclosingScrollportBox() const;
>     
>     virtual Optional<int> firstLineBaseline() const { return Optional<int>(); }
>     virtual Optional<int> inlineBlockBaseline(LineDirectionMode) const { return Optional<int>(); } // Returns empty if we should skip this box when computing the baseline of an inline-block.
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index e210bae9ac6e74400bc8d3d3adb2f4acc9261693..e06c609c83f4a6a57c3477b937bc04efe256bbc2 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,27 @@
>+2019-05-02  Joonghun Park  <jh718.park@samsung.com>
>+
>+        Resolve the percentage values of inset properties against proper box.
>+        https://bugs.webkit.org/show_bug.cgi?id=189549
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Before this CL, sticky element's layout was executed relative to
>+        a box's overflow container,
>+        but the value returned by getComputedStyle was resolved against
>+        its containing block.
>+
>+        So, the computed value and the actual value used in layout
>+        was different before this change.
>+
>+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt.
>+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html.
>+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt:
>+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html:
>+        * web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt: Added.
>+        * web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html: Added.
>+        * web-platform-tests/css/cssom/support/getComputedStyle-insets.js:
>+        (runTestsWithWM):
>+
> 2019-05-02  Frederic Wang  <fwang@igalia.com>
> 
>         [GTK][WPE] Disable "thin", "thick", "medium" values of mfrac@linethickness at runtime
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..19812d3feb9177986e23155e3494c384b0f1dacd
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt
>@@ -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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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-container-for-abspos.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..7f5ec3064837f4af37cf33050917768eb8ee0584
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
>@@ -0,0 +1,26 @@
>+<!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/#sticky-pos">
>+<link rel="author" title="Joonghun Park" href="mailto:pjh0718@gmail.com">
>+<style>
>+    #container-for-abspos {
>+        height: 200px;
>+        width: 400px;
>+        overflow: hidden;
>+    }
>+</style>
>+<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: sticky;",
>+  containingBlockElement: containerForAbspos,
>+  containingBlockArea: "content",
>+  preservesPercentages: false,
>+  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
>index 436ed0c96f1cd4a74d14f89fb416a13230ebb67c..19812d3feb9177986e23155e3494c384b0f1dacd 100644
>--- 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
>@@ -1,253 +1,253 @@
> 
> 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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 - 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 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
>index 6149acc6d7d0391d7a4d7ece12b9ec9c4b39041d..6b23fabcb1407c00ab1d35bbae77f6501b17f73f 100755
>--- 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
>@@ -4,12 +4,15 @@
> <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">
>+<style>
>+    #container-for-inflow { overflow: hidden; }
>+</style>
> <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",
>+  style: "position: sticky;",
>   containingBlockElement: containerForInflow,
>   containingBlockArea: "content",
>   preservesPercentages: false,
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..8f040044594737ad405f155ffc6583955e9c048b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Sticky element's top property percentage value should be resolved against the div with overflow: hidden 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..12ad5e89653564f91006c78baeac353c12865c00
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html
>@@ -0,0 +1,22 @@
>+<!DOCTYPE html>
>+<title>CSS Test: resolve top percentage value against proper box</title>
>+<link rel="help" href="https://github.com/w3c/csswg-drafts/issues/3115" />
>+<link rel="help" href="https://drafts.csswg.org/css-position/#sticky-pos" />
>+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-values" />
>+<meta name="assert" content="Test that the sticky percentage insets are
>+resolved against the right ancestor, i.e. the nearest scrollport." />
>+
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+
>+<div style="height: 500px; background: purple; overflow: hidden;">
>+  <div style="height: 400px; background: yellow;">
>+    <div id="target" style="height: 100px; position: sticky; left: 0; top: 50%; background: blue;">
>+    </div>
>+  </div>
>+</div>
>+<script>
>+test(() => {
>+  assert_equals(getComputedStyle(target).top, '250px');
>+}, "Sticky element's top property percentage value should be resolved against the div with overflow: hidden");
>+</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
>index beec32e76bc5fcef4640193e321805975c8554b9..723990cafbca5aef05a32294d5db28b899a226cc 100755
>--- 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
>@@ -22,7 +22,6 @@ stylesheet.textContent = `
>     padding: 1px 2px;
>     border-width: 2px 4px;
>     margin: 4px 8px;
>-    overflow: hidden;
>   }
>   #container-for-abspos {
>     /* Padding area: 200px tall, 400px wide */
>@@ -48,7 +47,7 @@ stylesheet.textContent = `
>     border-style: solid;
>   }
> `;
>-document.head.appendChild(stylesheet);
>+document.head.prepend(stylesheet);
> 
> function runTestsWithWM(data, testWM, cbWM) {
>   const {
>@@ -149,10 +148,10 @@ function runTestsWithWM(data, testWM, cbWM) {
>       bottom: "50%",
>       right: "75%",
>     }, {
>-      top: .1 * cbHeight + "px",
>-      left: .25 * cbWidth + "px",
>-      bottom: .5 * cbHeight + "px",
>-      right: .75 * cbWidth + "px",
>+      top: cbHeight * 10 / 100 + "px",
>+      left: cbWidth * 25 / 100 + "px",
>+      bottom: cbHeight * 50 / 100 + "px",
>+      right: cbWidth * 75 / 100 + "px",
>     }, "Percentages are absolutized into pixels");
> 
>     checkStyle({
>@@ -161,10 +160,10 @@ function runTestsWithWM(data, testWM, cbWM) {
>       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",
>+      top: cbHeight * 10 / 100 - 1 + "px",
>+      left: cbWidth * 25 / 100 - 2 + "px",
>+      bottom: cbHeight * 50 / 100 - 3 + "px",
>+      right: cbWidth * 75 / 100 - 4 + "px",
>     }, "calc() is absolutized into pixels");
>   }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 189549: 368906 | 368912