Auto merge of #29677 - mrobinson:resolved-insets, r=delan

Better implement getComputedStyle() for positioned insets

The specification dictates quite quite idiosyncratic return values when
querying insets of positioned elements via `getComputedStyle()`. These
depend on whether or not the element's size was overconstrained. This
change adds a better implementation of that in preparation for returning
proper values for `position: sticky`.

There are two changes here:
- The containing block used in `FragmentTree::find` is properly computed using the `ContainingBlockManager` data structure. This data structure is now updated during traversal through the fragment tree in `Fragment::find`.
- We now take into account whether or not a absolute elements are overconstrained when calculating their resolved insets. For absolutely positioned elements, this happens during absolute positioning. For relatively positioned elements, we can determine this when a `BoxFragment` is constructed.

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [x] There are tests for these changes

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->
This commit is contained in:
bors-servo 2023-05-09 12:09:51 +02:00 committed by GitHub
commit 818ee77d9d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 801 additions and 1318 deletions

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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