Attachment 349324 Details for Bug 188711 – Patch

[patch] Patch

bug-188711-20180910222942.patch (text/plain), 187.20 KB, created by Oriol Brufau on 2018-09-10 13:29:43 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Oriol Brufau

Created: 2018-09-10 13:29:43 PDT

Size: 187.20 KB

patch

obsolete

>Subversion Revision: 235665
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 225cb67172d7153f28882bcc55b69ab091556e9e..ad1261d33558c2cd164665d91df6b68f186afb7a 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,31 @@
>+2018-09-05  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 NOBODY (OOPS!).
>+
>+        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 sticky positioning, the resolved value of inset properties is absolutizes
>+           percentages.
>+         - In fixed positioning, the resolved value of non-'auto' values is no longer
>+           increased by the padding of the containg block.
>+
>+        Some tests still have failures due to unrelated issues.
>+
>+        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-09-04  Frederic Wang  <fwang@igalia.com>
> 
>         Add basic support for ScrollIntoViewOptions
>diff --git a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>index db9c6d79e087651443f074b6a0800a0f8a3e526c..5b991a9cf2ba8a51046a51f515e18facc1a104a9 100644
>--- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>+++ b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>@@ -772,22 +772,55 @@ 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.
>+    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned()) {
>+        bool isVerticalProperty;
>+        switch (propertyID) {
>+        case CSSPropertyTop:
>+        case CSSPropertyBottom:
>+            isVerticalProperty = true;
>+            break;
>+        case CSSPropertyLeft:
>+        case CSSPropertyRight:
>+            isVerticalProperty = false;
>+            break;
>+        default:
>+            ASSERT_NOT_REACHED();
>+        }
>+        LayoutUnit containingBlockSize;
>+        if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
>+            containingBlockSize = box.containingBlockLogicalHeightForPositioned(*containingBlock, false);
>+            if (!box.isOutOfFlowPositioned())
>+                containingBlockSize -= containingBlock->paddingLogicalHeight();
>+        } else {
>+            containingBlockSize = box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false);
>+            if (!box.isOutOfFlowPositioned())
>+                containingBlockSize -= containingBlock->paddingLogicalWidth();
>+        }
>+        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
>diff --git a/Source/WebCore/rendering/RenderBox.h b/Source/WebCore/rendering/RenderBox.h
>index 81663f74d2b9add13be6d647b4325ecdac46cef5..6e761dc3d53ea3f11e57dce7187452a82f6e1bcb 100644
>--- a/Source/WebCore/rendering/RenderBox.h
>+++ b/Source/WebCore/rendering/RenderBox.h
>@@ -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;
>@@ -686,9 +687,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,
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index cf7b31b0ff0b0823f5dc2948d8d5e026eb1b9ac9..06beb1236b0ac9d91eb3dcd4d3197c6d487f978e 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,39 @@
>+2018-09-05  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 NOBODY (OOPS!).
>+
>+        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 sticky positioning, the resolved value of inset properties is absolutizes
>+           percentages.
>+         - In fixed positioning, the resolved value of non-'auto' values is no longer
>+           increased by the padding of the containg block.
>+
>+        Some tests still have failures due to unrelated issues.
>+
>+        * 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-09-04  Frederic Wang  <fwang@igalia.com>
> 
>         Add basic support for ScrollIntoViewOptions
>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
>index 0000000000000000000000000000000000000000..4a1800cc4cc5866acd3a33a0d9a32563ce9ca9e4
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute-expected.txt
>@@ -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 100644
>index 0000000000000000000000000000000000000000..196f5f26f31f71253aa33b581f7a64ce3604e8da
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-absolute.html
>@@ -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@crisal.io">
>+<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
>index 0000000000000000000000000000000000000000..1c946298fe82e2febad139a8f4ea76f32244d614
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed-expected.txt
>@@ -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 100644
>index 0000000000000000000000000000000000000000..e57e774fe6eb27be91fa95d920096ba107512b1b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-fixed.html
>@@ -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@crisal.io">
>+<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
>index 0000000000000000000000000000000000000000..cbcbf7999286ff28aafbb999fbb1e38a1a01437c
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox-expected.txt
>@@ -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 100644
>index 0000000000000000000000000000000000000000..ca55ace7f4ed42ae25dab7968b347f83a998b958
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-nobox.html
>@@ -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@crisal.io">
>+<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
>index 0000000000000000000000000000000000000000..bc629b055cd633e45c83cd4f17ba4cd5dcea2e2f
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative-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 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 100644
>index 0000000000000000000000000000000000000000..c48f2eb555ee51c464753d980deeac514c84fd29
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-relative.html
>@@ -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@crisal.io">
>+<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
>index 0000000000000000000000000000000000000000..cbcbf7999286ff28aafbb999fbb1e38a1a01437c
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static-expected.txt
>@@ -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 100644
>index 0000000000000000000000000000000000000000..854a8e3dba4085ab1fa8fe3c48fde4ef2c27bca6
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-static.html
>@@ -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@crisal.io">
>+<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
>index 0000000000000000000000000000000000000000..19812d3feb9177986e23155e3494c384b0f1dacd
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-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.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..10520232d738a6547ee430797c74763649e06224
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html
>@@ -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@crisal.io">
>+<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 100644
>index 0000000000000000000000000000000000000000..d459d25ac4894e522501ba186bba6094050ad645
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js
>@@ -0,0 +1,372 @@
>+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;
>+  }
>+  #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({...declarations, ...testWM.style});
>+      if (containingBlockElement) {
>+        containingBlockElement.style.cssText = serialize({...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) {
>+    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);
>+    }
>+  }
>+}

Actions: View | Formatted Diff | Diff

Attachments on bug 188711: 347507 | 349324 | 349333 | 349350 | 349369 | 349435 | 349471 | 349472 | 349474 | 349482 | 349549 | 350362 | 351676 | 351898